[ { "path": ".gitattributes", "content": "# Ignore Python files in linguist\n*.py linguist-detectable=false\n\n# Images\n*.gif filter=lfs diff=lfs merge=lfs -text\n*.jpg filter=lfs diff=lfs merge=lfs -text\n*.png filter=lfs diff=lfs merge=lfs -text\n*.psd filter=lfs diff=lfs merge=lfs -text\n\n# Archives\n*.gz filter=lfs diff=lfs merge=lfs -text\n*.tar filter=lfs diff=lfs merge=lfs -text\n*.zip filter=lfs diff=lfs merge=lfs -text\n# Documents\n*.pdf filter=lfs diff=lfs merge=lfs -text\n# Numpy data\n*.npy filter=lfs diff=lfs merge=lfs -text\n# Debian package\n*.deb filter=lfs diff=lfs merge=lfs -text\n# Shared libraries\n*.so.* filter=lfs diff=lfs merge=lfs -text\n*.so filter=lfs diff=lfs merge=lfs -text\n*.a filter=lfs diff=lfs merge=lfs -text\n\n# trtexec\ntrtexec_x86_64 filter=lfs diff=lfs merge=lfs -text\n\n" }, { "path": ".gitignore", "content": "# Ignore all pycache files\n**/__pycache__/**\n# Ignore ROS build files\n**/build/**\n**/install/**\n**/cc_internals/**\n**/log/**\n" }, { "path": "LICENSE", "content": "NVIDIA ISAAC ROS SOFTWARE LICENSE\n\nThis license is a legal agreement between you and NVIDIA Corporation (\"NVIDIA\") and governs the use of the NVIDIA Isaac ROS software and materials provided hereunder (“SOFTWARE”).\n\nThis license can be accepted only by an adult of legal age of majority in the country in which the SOFTWARE is used. \n\nIf you are entering into this license on behalf of a company or other legal entity, you represent that you have the legal authority to bind the entity to this license, in which case “you” will mean the entity you represent. \n\nIf you don’t have the required age or authority to accept this license, or if you don’t accept all the terms and conditions of this license, do not download, install or use the SOFTWARE. \n\nYou agree to use the SOFTWARE only for purposes that are permitted by (a) this license, and (b) any applicable law, regulation or generally accepted practices or guidelines in the relevant jurisdictions.\n\n1. LICENSE. Subject to the terms of this license, NVIDIA hereby grants you a non-exclusive, non-transferable license, without the right to sublicense (except as expressly provided in this license) to:\na. Install and use the SOFTWARE,\nb. Modify and create derivative works of sample or reference source code delivered in the SOFTWARE, and\nc. Distribute any part of the SOFTWARE (i) as incorporated into a software application that has material additional functionality beyond the included portions of the SOFTWARE, or (ii) unmodified in binary format, in each case subject to the distribution requirements indicated in this license.\n\n2. DISTRIBUTION REQUIREMENTS. These are the distribution requirements for you to exercise the distribution grant above:\n a. The following notice shall be included in modifications and derivative works of source code distributed: “This software contains source code provided by NVIDIA Corporation.” \n b. You agree to distribute the SOFTWARE subject to the terms at least as protective as the terms of this license, including (without limitation) terms relating to the license grant, license restrictions and protection of NVIDIA’s intellectual property rights. Additionally, you agree that you will protect the privacy, security and legal rights of your application users. \n c. You agree to notify NVIDIA in writing of any known or suspected distribution or use of the SOFTWARE not in compliance with the requirements of this license, and to enforce the terms of your agreements with respect to the distributed portions of the SOFTWARE.\n3. AUTHORIZED USERS. You may allow employees and contractors of your entity or of your subsidiary(ies) to access and use the SOFTWARE from your secure network to perform work on your behalf. If you are an academic institution you may allow users enrolled or employed by the academic institution to access and use the SOFTWARE from your secure network. You are responsible for the compliance with the terms of this license by your authorized users. \n\n4. LIMITATIONS. Your license to use the SOFTWARE is restricted as follows:\n a. The SOFTWARE is licensed for you to develop applications only for their use in systems with NVIDIA GPUs.\n b. You may not reverse engineer, decompile or disassemble, or remove copyright or other proprietary notices from any portion of the SOFTWARE or copies of the SOFTWARE. \n c. Except as expressly stated above in this license, you may not sell, rent, sublicense, transfer, distribute, modify, or create derivative works of any portion of the SOFTWARE. \n d. Unless you have an agreement with NVIDIA for this purpose, you may not indicate that an application created with the SOFTWARE is sponsored or endorsed by NVIDIA.\n e. You may not bypass, disable, or circumvent any technical limitation, encryption, security, digital rights management or authentication mechanism in the SOFTWARE. \n f. You may not use the SOFTWARE in any manner that would cause it to become subject to an open source software license. As examples, licenses that require as a condition of use, modification, and/or distribution that the SOFTWARE be: (i) disclosed or distributed in source code form; (ii) licensed for the purpose of making derivative works; or (iii) redistributable at no charge.\n g. You acknowledge that the SOFTWARE as delivered is not tested or certified by NVIDIA for use in connection with the design, construction, maintenance, and/or operation of any system where the use or failure of such system could result in a situation that threatens the safety of human life or results in catastrophic damages (each, a \"Critical Application\"). Examples of Critical Applications include use in avionics, navigation, autonomous vehicle applications, ai solutions for automotive products, military, medical, life support or other life critical applications. NVIDIA shall not be liable to you or any third party, in whole or in part, for any claims or damages arising from such uses. You are solely responsible for ensuring that any product or service developed with the SOFTWARE as a whole includes sufficient features to comply with all applicable legal and regulatory standards and requirements.\n h. You agree to defend, indemnify and hold harmless NVIDIA and its affiliates, and their respective employees, contractors, agents, officers and directors, from and against any and all claims, damages, obligations, losses, liabilities, costs or debt, fines, restitutions and expenses (including but not limited to attorney’s fees and costs incident to establishing the right of indemnification) arising out of or related to your use of goods and/or services that include or utilize the SOFTWARE, or for use of the SOFTWARE outside of the scope of this license or not in compliance with its terms. \n\n5. UPDATES. NVIDIA may, at its option, make available patches, workarounds or other updates to this SOFTWARE. Unless the updates are provided with their separate governing terms, they are deemed part of the SOFTWARE licensed to you as provided in this license. \n\n6. PRE-RELEASE VERSIONS. SOFTWARE versions identified as alpha, beta, preview, early access or otherwise as pre-release may not be fully functional, may contain errors or design flaws, and may have reduced or different security, privacy, availability, and reliability standards relative to commercial versions of NVIDIA software and materials. You may use a pre-release SOFTWARE version at your own risk, understanding that these versions are not intended for use in production or business-critical systems.\n\n7. COMPONENTS UNDER OTHER LICENSES. The SOFTWARE may include NVIDIA or third-party components with separate legal notices or terms as may be described in proprietary notices accompanying the SOFTWARE, such as components governed by open source software licenses. If and to the extent there is a conflict between the terms in this license and the license terms associated with a component, the license terms associated with the component controls only to the extent necessary to resolve the conflict. \n\n8. OWNERSHIP. \n\n8.1 NVIDIA reserves all rights, title and interest in and to the SOFTWARE not expressly granted to you under this license. NVIDIA and its suppliers hold all rights, title and interest in and to the SOFTWARE, including their respective intellectual property rights. The SOFTWARE is copyrighted and protected by the laws of the United States and other countries, and international treaty provisions.\n\n8.2 Subject to the rights of NVIDIA and its suppliers in the SOFTWARE, you hold all rights, title and interest in and to your applications and your derivative works of the sample or reference source code delivered in the SOFTWARE including their respective intellectual property rights. With respect to source code samples or reference source code licensed to you, NVIDIA and its affiliates are free to continue independently developing source code samples and you covenant not to sue NVIDIA, its affiliates or their licensees with respect to later versions of NVIDIA released source code.\n \n9. FEEDBACK. You may, but are not obligated to, provide to NVIDIA Feedback. “Feedback” means suggestions, fixes, modifications, feature requests or other feedback regarding the SOFTWARE. Feedback, even if designated as confidential by you, shall not create any confidentiality obligation for NVIDIA. NVIDIA and its designees have a perpetual, non-exclusive, worldwide, irrevocable license to use, reproduce, publicly display, modify, create derivative works of, license, sublicense, and otherwise distribute and exploit Feedback as NVIDIA sees fit without payment and without obligation or restriction of any kind on account of intellectual property rights or otherwise.\n\n10. NO WARRANTIES. THE SOFTWARE IS PROVIDED AS-IS. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW NVIDIA AND ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, NON-INFRINGEMENT, OR FITNESS FOR A PARTICULAR PURPOSE. NVIDIA DOES NOT WARRANT THAT THE SOFTWARE WILL MEET YOUR REQUIREMENTS OR THAT THE OPERATION THEREOF WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ALL ERRORS WILL BE CORRECTED. \n\n11. LIMITATIONS OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW NVIDIA AND ITS AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL DAMAGES, OR FOR ANY LOST PROFITS, PROJECT DELAYS, LOSS OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION WITH THIS LICENSE OR THE USE OR PERFORMANCE OF THE SOFTWARE, WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF LIABILITY, EVEN IF NVIDIA HAS PREVIOUSLY BEEN ADVISED OF, OR COULD REASONABLY HAVE FORESEEN, THE POSSIBILITY OF SUCH DAMAGES. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS LICENSE EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS LIMIT. \n\n12. TERMINATION. Your rights under this license will terminate automatically without notice from NVIDIA if you fail to comply with any term and condition of this license or if you commence or participate in any legal proceeding against NVIDIA with respect to the SOFTWARE. NVIDIA may terminate this license with advance written notice to you, if NVIDIA decides to no longer provide the SOFTWARE in a country or, in NVIDIA’s sole discretion, the continued use of it is no longer commercially viable. Upon any termination of this license, you agree to promptly discontinue use of the SOFTWARE and destroy all copies in your possession or control. Your prior distributions in accordance with this license are not affected by the termination of this license. All provisions of this license will survive termination, except for the license granted to you. \n\n13. APPLICABLE LAW. This license will be governed in all respects by the laws of the United States and of the State of Delaware, without regard to the conflicts of laws principles. The United Nations Convention on Contracts for the International Sale of Goods is specifically disclaimed. You agree to all terms of this license in the English language. The state or federal courts residing in Santa Clara County, California shall have exclusive jurisdiction over any dispute or claim arising out of this license. Notwithstanding this, you agree that NVIDIA shall still be allowed to apply for injunctive remedies or urgent legal relief in any jurisdiction. \n\n14. NO ASSIGNMENT. This license and your rights and obligations thereunder may not be assigned by you by any means or operation of law without NVIDIA’s permission. Any attempted assignment not approved by NVIDIA in writing shall be void and of no effect. NVIDIA may assign, delegate or transfer this license and its rights and obligations, and if to a non-affiliate you will be notified.\n \n15. EXPORT. The SOFTWARE is subject to United States export laws and regulations. You agree to comply with all applicable U.S. and international export laws, including the Export Administration Regulations (EAR) administered by the U.S. Department of Commerce and economic sanctions administered by the U.S. Department of Treasury’s Office of Foreign Assets Control (OFAC). These laws include restrictions on destinations, end-users and end-use. By accepting this license, you confirm that you are not currently residing in a country or region currently embargoed by the U.S. and that you are not otherwise prohibited from receiving the SOFTWARE.\n\n16. GOVERNMENT USE. The SOFTWARE is, and shall be treated as being, “Commercial Items” as that term is defined at 48 CFR § 2.101, consisting of “commercial computer software” and “commercial computer software documentation”, respectively, as such terms are used in, respectively, 48 CFR § 12.212 and 48 CFR §§ 227.7202 & 252.227-7014(a)(1). Use, duplication or disclosure by the U.S. Government or a U.S. Government subcontractor is subject to the restrictions in this license pursuant to 48 CFR § 12.212 or 48 CFR § 227.7202. In no event shall the US Government user acquire rights in the SOFTWARE beyond those specified in 48 C.F.R. 52.227-19(b)(1)-(2). \n\n17. NOTICES. Please direct your legal notices or other correspondence to NVIDIA Corporation, 2788 San Tomas Expressway, Santa Clara, California 95051, United States of America, Attention: Legal Department.\n\n18. ENTIRE AGREEMENT. This license is the final, complete and exclusive agreement between the parties relating to the subject matter of this license and supersedes all prior or contemporaneous understandings and agreements relating to this subject matter, whether oral or written. If any court of competent jurisdiction determines that any provision of this license is illegal, invalid or unenforceable, the remaining provisions will remain in full force and effect. Any amendment or waiver under this license shall be in writing and signed by representatives of both parties.\n\n(v. November 17, 2021) \n" }, { "path": "README.md", "content": "# Isaac ROS NITROS\n\nNVIDIA Isaac Transport for ROS package for hardware-acceleration friendly movement of messages.\n\n
\"image\"
\n\n## Overview\n\nIsaac ROS NITROS contains NVIDIA’s implementation\nof type adaptation and negotiation in ROS 2. To learn more about NITROS, see [here](https://nvidia-isaac-ros.github.io/concepts/nitros/index.html).\n\nIsaac ROS NITROS is composed of a number of individual packages, each with either a functional or structural purpose:\n\n`isaac_ros_gxf`:\n: This package serves as a container for precompiled GXF extensions used by other Isaac ROS packages.\n While a number of GXF extensions used by Isaac ROS are provided with source, the extensions contained in `isaac_ros_gxf` are license constrained and are thus shipped as `.so` binaries.\n\n`isaac_ros_managed_nitros`:\n: This package contains the wrapper classes that enable developers to add NITROS-compatible publishers and subscribers to third-party CUDA-based ROS nodes.\n For more information about CUDA with NITROS, see [here](https://nvidia-isaac-ros.github.io/concepts/nitros/cuda_with_nitros.html).\n\n`isaac_ros_nitros`:\n: This package contains the base `NitrosNode` class and associated core utilities that serve as the foundation for all NITROS-based ROS nodes.\n\n`isaac_ros_nitros_bridge`:\n: This folder contains the implementation of the NITROS Bridge for inter-process communication.\n\n`isaac_ros_nitros_interfaces`:\n: This package contains the definitions of the custom ROS 2 interfaces that facilitate type negotiation between NITROS nodes.\n\n`isaac_ros_nitros_topic_tools`:\n: This folder contains a NITROS based implementation of some of the nodes in the [topic_tools package](https://github.com/ros-tooling/topic_tools).\n\n`isaac_ros_nitros_type`:\n: This folder contains a number of packages, each defining a specific NITROS type and the associated type adaptation logic to convert to and from a standard ROS type.\n\n`isaac_ros_pynitros`:\n: This folder contains the implementation of Python NITROS.\n\n---\n\n## Documentation\n\nPlease visit the [Isaac ROS Documentation](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/index.html) to learn how to use this repository.\n\n---\n\n## Packages\n\n* [`isaac_ros_gxf`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_gxf/index.html)\n* [`isaac_ros_managed_nitros`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_managed_nitros/index.html)\n* [`isaac_ros_nitros`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros/index.html)\n * [Quickstart](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros/index.html#quickstart)\n* [Isaac ROS NITROS Bridge](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html)\n * [Overview](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#overview)\n * [Performance](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#performance)\n * [Packages](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#packages)\n * [Quickstart](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#quickstart)\n * [Try Another Example](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#try-another-example)\n * [Troubleshooting](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#troubleshooting)\n * [Updates](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#updates)\n* [`isaac_ros_nitros_bridge_ros2`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/isaac_ros_nitros_bridge_ros2/index.html)\n * [API](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/isaac_ros_nitros_bridge_ros2/index.html#api)\n* [`isaac_ros_nitros_topic_tools`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_topic_tools/index.html)\n * [NitrosCameraDrop Node](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_topic_tools/index.html#nitroscameradrop-node)\n* [`isaac_ros_nitros_type`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_type/index.html)\n* [`isaac_ros_pynitros`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html)\n * [Creating PyNITROS-Accelerated Nodes](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html#creating-pynitros-accelerated-nodes)\n * [Quickstart](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html#quickstart)\n * [Try More Examples](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html#try-more-examples)\n * [API Reference](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html#api-reference)\n\n## Latest\n\nUpdate 2026-04-30: Compatibility and integration updates for the Isaac ROS 4.4.0 release\n" }, { "path": "SECURITY.md", "content": "## Security\n\nNVIDIA is dedicated to the security and trust of our software products and services, including all source code repositories managed through our organization.\n\nIf you need to report a security issue, please use the appropriate contact points outlined below. **Please do not report security vulnerabilities through GitHub.** If a potential security issue is inadvertently reported via a public issue or pull request, NVIDIA maintainers may limit public discussion and redirect the reporter to the appropriate private disclosure channels.\n\n## Reporting Potential Security Vulnerability in an NVIDIA Product\n\nTo report a potential security vulnerability in any NVIDIA product:\n- Web: [Security Vulnerability Submission Form](https://www.nvidia.com/object/submit-security-vulnerability.html)\n- E-Mail: psirt@nvidia.com\n - We encourage you to use the following PGP key for secure email communication: [NVIDIA public PGP Key for communication](https://www.nvidia.com/en-us/security/pgp-key)\n - Please include the following information:\n \t - Product/Driver name and version/branch that contains the vulnerability\n - Type of vulnerability (code execution, denial of service, buffer overflow, etc.)\n \t - Instructions to reproduce the vulnerability\n \t - Proof-of-concept or exploit code\n \t - Potential impact of the vulnerability, including how an attacker could exploit the vulnerability\n\nWhile NVIDIA currently does not have a bug bounty program, we do offer acknowledgement when an externally reported security issue is addressed under our coordinated vulnerability disclosure policy. Please visit our [Product Security Incident Response Team (PSIRT)](https://www.nvidia.com/en-us/security/psirt-policies/) policies page for more information.\n\n## NVIDIA Product Security\n\nFor all security-related concerns, please visit NVIDIA's Product Security portal at https://www.nvidia.com/en-us/security\n" }, { "path": "isaac_ros_gxf/CMakeLists.txt", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\ncmake_minimum_required(VERSION 3.22.1)\nproject(isaac_ros_gxf)\n\n# Add option for overriding GXF core library directory\noption(GXF_CORE_LIB_DIR_OVERRIDE \"Override path for GXF core library directory\" \"\")\n\nexecute_process(COMMAND uname -m COMMAND tr -d '\\n' OUTPUT_VARIABLE ARCHITECTURE)\nmessage( STATUS \"Architecture: ${ARCHITECTURE}\" )\n\nfind_package(ament_cmake_auto REQUIRED)\nament_auto_find_build_dependencies()\n\nadd_library(${PROJECT_NAME} STATIC src/isaac_ros_gxf.cpp)\n\n# GXF core headers\ninstall(\n DIRECTORY gxf/core/include/\n DESTINATION share/${PROJECT_NAME}/gxf/include/\n)\n\n# Install extensions directory\nif( ${ARCHITECTURE} STREQUAL \"x86_64\" )\n install(DIRECTORY gxf/core/lib/gxf_x86_64_cuda_13_0/ DESTINATION share/${PROJECT_NAME}/gxf/lib)\n install(FILES gxf/core/lib/gxf_x86_64_cuda_13_0/core/libgxf_core.so DESTINATION lib)\n install(FILES gxf/core/lib/gxf_x86_64_cuda_13_0/logger/libgxf_logger.so DESTINATION lib)\n install(FILES gxf/core/lib/gxf_x86_64_cuda_13_0/multimedia/libgxf_multimedia.so DESTINATION lib)\n install(FILES gxf/core/lib/gxf_x86_64_cuda_13_0/cuda/libgxf_cuda.so DESTINATION lib)\nelseif( ${ARCHITECTURE} STREQUAL \"aarch64\" )\n if(CMAKE_DEVICE STREQUAL \"sbsa\")\n set(GXF_CORE_LIB_DIR gxf/core/lib/gxf_aarch64_cuda_13_0/)\n elseif(CMAKE_DEVICE STREQUAL \"arm64\")\n set(GXF_CORE_LIB_DIR gxf/core/lib/gxf_jetpack70/)\n else()\n message(FATAL_ERROR \"Device is not supported.\")\n endif()\n install(DIRECTORY ${GXF_CORE_LIB_DIR} DESTINATION share/${PROJECT_NAME}/gxf/lib)\n install(FILES ${GXF_CORE_LIB_DIR}/core/libgxf_core.so DESTINATION lib)\n install(FILES ${GXF_CORE_LIB_DIR}/logger/libgxf_logger.so DESTINATION lib)\n install(FILES ${GXF_CORE_LIB_DIR}/multimedia/libgxf_multimedia.so DESTINATION lib)\n install(FILES ${GXF_CORE_LIB_DIR}/cuda/libgxf_cuda.so DESTINATION lib)\nendif()\n\n# Register cmake in install.\nament_index_register_resource(isaac_ros_gxf_cmake_path CONTENT\n \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/cmake\")\nlist(APPEND ${PROJECT_NAME}_CONFIG_EXTRAS cmake/isaac_ros_gxf-extras.cmake)\n\n# Core\nadd_library(Core INTERFACE)\nset_target_properties(Core PROPERTIES\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\"\n)\nset_property(TARGET Core PROPERTY\n INTERFACE_LINK_LIBRARIES\n magic_enum::magic_enum\n \"$/lib/libgxf_core.so\"\n)\n\n# Logger\nadd_library(Logger INTERFACE)\nset_target_properties(Logger PROPERTIES\n INTERFACE_LINK_LIBRARIES\n \"$/share/${PROJECT_NAME}/gxf/lib/logger/libgxf_logger.so\"\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\"\n)\n\n# Std\nadd_library(Std INTERFACE)\nset_target_properties(Std PROPERTIES\n INTERFACE_LINK_LIBRARIES\n \"$/share/${PROJECT_NAME}/gxf/lib/std/libgxf_std.so\"\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\"\n)\n\n# Multimedia\nadd_library(Multimedia INTERFACE)\nset_target_properties(Multimedia PROPERTIES\n INTERFACE_LINK_LIBRARIES\n \"$/share/${PROJECT_NAME}/gxf/lib/multimedia/libgxf_multimedia.so\"\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\"\n)\n\n# Serialization\nadd_library(Serialization INTERFACE)\nset_target_properties(Serialization PROPERTIES\n INTERFACE_LINK_LIBRARIES\n \"$/share/${PROJECT_NAME}/gxf/lib/serialization/libgxf_serialization.so\"\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\"\n)\n\n# Cuda\nadd_library(Cuda INTERFACE)\nset_target_properties(Cuda PROPERTIES\n INTERFACE_LINK_LIBRARIES\n \"$/share/${PROJECT_NAME}/gxf/lib/cuda/libgxf_cuda.so\"\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\"\n)\n\ninstall(TARGETS Core Logger Std Multimedia Serialization Cuda\n EXPORT export_${PROJECT_NAME}\n LIBRARY DESTINATION lib\n ARCHIVE DESTINATION lib\n RUNTIME DESTINATION bin)\nament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)\n\nif(BUILD_TESTING)\n find_package(ament_lint_auto REQUIRED)\n\n # Ignore copyright notices since we use custom NVIDIA Isaac ROS Software License\n set(ament_cmake_copyright_FOUND TRUE)\n ament_lint_auto_find_test_dependencies()\nendif()\n\n\n# Embed versioning information into installed files\nament_index_get_resource(ISAAC_ROS_COMMON_CMAKE_PATH isaac_ros_common_cmake_path isaac_ros_common)\ninclude(\"${ISAAC_ROS_COMMON_CMAKE_PATH}/isaac_ros_common-version-info.cmake\")\ngenerate_version_info(${PROJECT_NAME})\n\nament_auto_package(INSTALL_TO_SHARE cmake)\n" }, { "path": "isaac_ros_gxf/cmake/isaac_ros_gxf-extras.cmake", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\n# Common flags and cmake commands for all Isaac ROS packages based on NITROS\n\nmessage(STATUS \"Loading isaac_ros_gxf extras\")\n\n# Append local cmake module path for CMAKE_MODULE_PATH\nament_index_get_resource(ISAAC_ROS_GXF_CMAKE_PATH isaac_ros_gxf_cmake_path isaac_ros_gxf)\nlist(APPEND CMAKE_MODULE_PATH \"${ISAAC_ROS_GXF_CMAKE_PATH}/modules\")\n\n# Versions\nset(ISAAC_ROS_GXF_VERSION 2.5.0)" }, { "path": "isaac_ros_gxf/cmake/modules/FindGXF.cmake", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\n# Create GXF imported cmake targets\n#\n# This module defines GXF_FOUND if all GXF libraries are found or\n# if the required libraries (COMPONENTS property in find_package)\n# are found.\n#\n# A new imported target is created for each component (library)\n# under the GXF namespace (GXF::${component_name})\n#\n# Note: this leverages the find-module paradigm [1]. The config-file paradigm [2]\n# is recommended instead in CMake.\n# [1] https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#config-file-packages\n# [2] https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#find-module-packages\n\n# Library names\nlist(APPEND _GXF_EXTENSIONS\n cuda\n multimedia\n serialization\n std\n)\n\nlist(APPEND GXF_BASE_PATHS \"${isaac_ros_gxf_DIR}/../../../share/isaac_ros_gxf/gxf\")\n\n# Common headers\nfind_path(GXF_common_INCLUDE_DIR\n NAMES common/\n PATHS ${GXF_BASE_PATHS}\n PATH_SUFFIXES include/\n REQUIRED\n)\n\nmark_as_advanced(GXF_common_INCLUDE_DIR)\nlist(APPEND GXF_INCLUDE_DIR_VARS GXF_common_INCLUDE_DIR)\n\n# Libraries and their headers\nlist(APPEND _GXF_LIBRARIES ${_GXF_EXTENSIONS} core)\n\nforeach(component IN LISTS _GXF_LIBRARIES)\n # headers\n find_path(GXF_${component}_INCLUDE_DIR\n NAMES \"${component}/\"\n PATHS ${GXF_BASE_PATHS}\n PATH_SUFFIXES\n include\n include/gxf\n NO_DEFAULT_PATH\n REQUIRED\n )\n mark_as_advanced(GXF_${component}_INCLUDE_DIR)\n list(APPEND GXF_INCLUDE_DIR_VARS GXF_${component}_INCLUDE_DIR)\n\n # library\n find_library(GXF_${component}_LIBRARY\n NAMES \"gxf_${component}\" \"${component}\"\n PATHS ${GXF_BASE_PATHS}\n PATH_SUFFIXES\n lib/${component}\n lib/${GXF_PLATFORM_SUFFIX}\n lib/${GXF_PLATFORM_SUFFIX}/${component}\n lib/${GXF_PLATFORM_SUFFIX}/isaac\n lib/${GXF_PLATFORM_SUFFIX}/isaac/${component}\n REQUIRED\n )\n mark_as_advanced(GXF_${component}_LIBRARY)\n list(APPEND GXF_LIBRARY_VARS GXF_${component}_LIBRARY)\n\n # create imported target\n if(GXF_${component}_LIBRARY AND GXF_${component}_INCLUDE_DIR)\n set(gxf_component_location \"${GXF_${component}_LIBRARY}\")\n\n if(NOT TARGET GXF::${component})\n # Assume SHARED, though technically UNKNOWN since we don't enforce .so\n add_library(GXF::${component} SHARED IMPORTED)\n endif()\n\n list(APPEND GXF_${component}_INCLUDE_DIRS\n ${GXF_${component}_INCLUDE_DIR}\n ${GXF_${component}_INCLUDE_DIR}/${component}\n ${GXF_common_INCLUDE_DIR}\n )\n\n message(STATUS \"Found ${component} lib=${gxf_component_location}, include=${GXF_${component}_INCLUDE_DIR}\")\n # Points to the copied location of GXF\n set_target_properties(GXF::${component} PROPERTIES\n IMPORTED_LOCATION \"${gxf_component_location}\"\n IMPORTED_NO_SONAME ON\n INTERFACE_INCLUDE_DIRECTORIES \"${GXF_${component}_INCLUDE_DIRS}\"\n )\n\n set(GXF_${component}_FOUND TRUE)\n else()\n message(FATAL_ERROR \"Could not find GXF::${component}: lib={GXF_${component}_LIBRARY} / include=${GXF_${component}_INCLUDE_DIR}\")\n set(GXF_${component}_FOUND FALSE)\n endif()\nendforeach()\n\nunset(_GXF_EXTENSIONS)\nunset(_GXF_LIBRARIES)\n\n# Find version\nif(GXF_core_INCLUDE_DIR)\n # Note: \"kGxfCoreVersion \\\"(.*)\\\"$\" does not work with a simple string\n # REGEX (doesn't stop and EOL, neither $ nor \\n), so we first extract\n # the line with file(STRINGS), then the version with string(REGEX)\n file(STRINGS \"${GXF_core_INCLUDE_DIR}/core/gxf.h\" _GXF_VERSION_LINE\n REGEX \"kGxfCoreVersion\"\n )\n string(REGEX MATCH \"kGxfCoreVersion \\\"(.*)\\\"\" _ ${_GXF_VERSION_LINE})\n set(GXF_VERSION ${CMAKE_MATCH_1})\n unset(_GXF_VERSION_LINE)\nendif()\n\n# Generate GXF_FOUND\ninclude(FindPackageHandleStandardArgs)\nfind_package_handle_standard_args(GXF\n FOUND_VAR GXF_FOUND\n VERSION_VAR GXF_VERSION\n HANDLE_COMPONENTS # Looks for GXF_${component}_FOUND\n)\n" }, { "path": "isaac_ros_gxf/gxf/AMENT_IGNORE", "content": "" }, { "path": "isaac_ros_gxf/gxf/core/include/common/assert.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_ASSERT_HPP_\n#define NVIDIA_COMMON_ASSERT_HPP_\n\n#include \n#include \n#include \n\n#include \"common/backtrace.hpp\"\n#include \"common/logger.hpp\"\n\n// Prints a panic message and aborts the program\n#define GXF_PANIC(...) \\\n { \\\n GXF_LOG_PANIC(__VA_ARGS__); \\\n PrettyPrintBacktrace(); \\\n std::exit(1); \\\n }\n\n// Checks if an expression evaluates to true. If not prints a panic message and aborts the program.\n#define GXF_ASSERT(expr, ...) \\\n if (!(expr)) { \\\n GXF_LOG_PANIC(__VA_ARGS__); \\\n PrettyPrintBacktrace(); \\\n std::exit(1); \\\n }\n\n#define GXF_ASSERT_SUCCESS(expr) \\\n { \\\n const auto _result = (expr); \\\n if (_result != 0) { \\\n GXF_LOG_PANIC(\"GXF operation failed: %s\", GxfResultStr(_result)); \\\n PrettyPrintBacktrace(); \\\n std::exit(1); \\\n } \\\n } \\\n\n// Asserts that A == true. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_TRUE(exp_a) \\\n { \\\n const auto _va = exp_a; \\\n GXF_ASSERT(_va == true, \"Assert failed: %s == true.\", std::to_string(_va).c_str()); \\\n }\n\n// Asserts that A == false. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_FALSE(exp_a) \\\n { \\\n const auto _va = exp_a; \\\n GXF_ASSERT(_va == false, \"Assert failed: %s == false.\", std::to_string(_va).c_str()); \\\n }\n\n// Asserts that A == B. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_EQ(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n GXF_ASSERT(_va == _vb, \"Assert failed: %s == %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A == B for two strings. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_STREQ(exp_a, exp_b) \\\n { \\\n const char* _va = (exp_a); \\\n const char* _vb = (exp_b); \\\n GXF_ASSERT(std::strcmp(_va, _vb) == 0, \"Assert failed: %s == %s.\", _va, _vb); \\\n }\n\n// Asserts that A != B. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_NE(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n GXF_ASSERT(_va != _vb, \"Assert failed: %s != %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A > B. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_GT(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n GXF_ASSERT(_va > _vb, \"Assert failed: %s > %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A >= B. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_GE(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n GXF_ASSERT(_va >= _vb, \"Assert failed: %s >= %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A > B. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_LT(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n GXF_ASSERT(_va < _vb, \"Assert failed: %s > %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A <= B. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_LE(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n GXF_ASSERT(_va <= _vb, \"Assert failed: %s <= %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that abs(A - B) <= abs_error. If not prints a panic message and aborts the program.\n#define GXF_ASSERT_NEAR(exp_a, exp_b, exp_abs_error) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n const auto _verror = exp_abs_error; \\\n GXF_ASSERT(std::abs(_va - _vb) <= _verror, \"Assert failed: abs(%s - %s) <= %s.\", \\\n std::to_string(_va).c_str(), std::to_string(_vb).c_str(), \\\n std::to_string(_verror).c_str()); \\\n }\n\n#endif // NVIDIA_COMMON_ASSERT_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/backtrace.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_BACKTRACE_HPP_\n#define NVIDIA_COMMON_BACKTRACE_HPP_\n\n// Print the stacktrace with demangled function names (if possible)\n// Function is disabled for QNX since execinfo.h is not available in the QNX toolchain\nvoid PrettyPrintBacktrace();\n\n#endif // NVIDIA_COMMON_BACKTRACE_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/byte.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_BYTE_HPP_\n#define NVIDIA_COMMON_BYTE_HPP_\n\n# if __cplusplus < 201703L\nnamespace std {\nusing byte = unsigned char;\n} // namespace std\nusing std::byte;\n# else\nnamespace nvidia {\n using byte = unsigned char;\n}\nusing nvidia::byte;\n\n#endif\n\n#endif // NVIDIA_COMMON_BYTE_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/endian.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_ENDIAN_HPP_\n#define NVIDIA_COMMON_ENDIAN_HPP_\n\n#ifdef _QNX_SOURCE\n#include \n#else\n#include \n#endif\n\n#include \"common/type_utils.hpp\"\n\nnamespace nvidia {\n\n/// Returns true if the machine stores multi-byte integers in little-endian format\n/// FIXME: Use std::memcpy if reinterpret_cast has to be removed\ninline bool IsLittleEndian() {\n const uint16_t test = 0x0102;\n return *reinterpret_cast(&test) == 0x02;\n}\n\n/// Convert @a value to little-endian.\n/// This overload should only be used if @c T is a signed integer type.\ntemplate >>\ninline T EncodeLittleEndian(T value) {\n static_assert(IsSigned_v);\n using U = MakeUnsigned_t;\n return static_cast(EncodeLittleEndian(static_cast(value)));\n}\n\ntemplate <> inline uint64_t EncodeLittleEndian(uint64_t value) { return htole64(value); }\ntemplate <> inline uint32_t EncodeLittleEndian(uint32_t value) { return htole32(value); }\ntemplate <> inline uint16_t EncodeLittleEndian(uint16_t value) { return htole16(value); }\ntemplate <> inline uint8_t EncodeLittleEndian (uint8_t value) { return value; }\n\n/// Convert @a value from little-endian.\n/// This overload should only be used if @c T is a signed integer type.\ntemplate >>\ninline T DecodeLittleEndian(T value) {\n static_assert(IsSigned_v);\n using U = MakeUnsigned_t;\n return static_cast(DecodeLittleEndian(static_cast(value)));\n}\n\ntemplate <> inline uint64_t DecodeLittleEndian(uint64_t value) { return le64toh(value); }\ntemplate <> inline uint32_t DecodeLittleEndian(uint32_t value) { return le32toh(value); }\ntemplate <> inline uint16_t DecodeLittleEndian(uint16_t value) { return le16toh(value); }\ntemplate <> inline uint8_t DecodeLittleEndian (uint8_t value) { return value; }\n\n/// Returns true if the machine stores multi-byte integers in big-endian format\n/// FIXME: Use std::memcpy if reinterpret_cast has to be removed\ninline bool IsBigEndian() {\n const uint16_t test = 0x0102;\n return *reinterpret_cast(&test) == 0x01;\n}\n\n/// Convert @a value to big-endian.\n/// This overload should only be used if @c T is a signed integer type.\ntemplate >>\ninline T EncodeBigEndian(T value) {\n static_assert(IsSigned_v);\n using U = MakeUnsigned_t;\n return static_cast(EncodeBigEndian(static_cast(value)));\n}\n\ntemplate <> inline uint64_t EncodeBigEndian(uint64_t value) { return htobe64(value); }\ntemplate <> inline uint32_t EncodeBigEndian(uint32_t value) { return htobe32(value); }\ntemplate <> inline uint16_t EncodeBigEndian(uint16_t value) { return htobe16(value); }\ntemplate <> inline uint8_t EncodeBigEndian (uint8_t value) { return value; }\n\n/// Convert @a value from big-endian.\n/// This overload should only be used if @c T is a signed integer type.\ntemplate >>\ninline T DecodeBigEndian(T value) {\n static_assert(IsSigned_v);\n using U = MakeUnsigned_t;\n return static_cast(DecodeBigEndian(static_cast(value)));\n}\n\ntemplate <> inline uint64_t DecodeBigEndian(uint64_t value) { return be64toh(value); }\ntemplate <> inline uint32_t DecodeBigEndian(uint32_t value) { return be32toh(value); }\ntemplate <> inline uint16_t DecodeBigEndian(uint16_t value) { return be16toh(value); }\ntemplate <> inline uint8_t DecodeBigEndian (uint8_t value) { return value; }\n\n} // namespace nvidia\n\n#endif // NVIDIA_COMMON_ENDIAN_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/expected.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_EXPECTED_HPP_\n#define NVIDIA_COMMON_EXPECTED_HPP_\n\n#include \n\n#include \"common/assert.hpp\"\n#include \"common/memory_utils.hpp\"\n#include \"common/strong_type.hpp\"\n#include \"common/type_utils.hpp\"\n\nnamespace nvidia {\n\ntemplate using Unexpected = StrongType;\ntemplate class Expected;\n\n///-------------------------------------------------------------------------------------------------\n/// Local Helper Functions\n///-------------------------------------------------------------------------------------------------\nnamespace detail {\n\ntemplate \nstruct IsExpectedHelper : FalseType {};\n\ntemplate \nstruct IsExpectedHelper> : TrueType {};\n\ntemplate \nusing IsExpected = IsExpectedHelper>;\n\ntemplate \nconstexpr bool IsExpected_v = IsExpected::value;\n\n// Extracts the error type from a pack of Expecteds if they all contain the same Error .\ntemplate \nstruct ErrorTypeHelper : TypeIdentity {};\n\ntemplate \nstruct ErrorTypeHelper...> : TypeIdentity {};\n\ntemplate \nusing ErrorType = typename ErrorTypeHelper...>::type;\n\ntemplate \nusing ErrorTypeOr = Conditional_t>;\n\n// Extracts the error type from a pack of Expecteds if they all contain the same Error .\ntemplate \nstruct ValueTypeHelper {};\n\ntemplate \nstruct ValueTypeHelper> { using type = T; };\n\ntemplate \nusing ValueType = typename ValueTypeHelper>::type;\n\n// Extracts the type from a Unexpected if provided. Otherwise, returns the type T.\ntemplate \nstruct UnexpectedTypeHelper : TypeIdentity {};\n\ntemplate \nstruct UnexpectedTypeHelper> : TypeIdentity {};\n\ntemplate \nusing UnexpectedType = typename UnexpectedTypeHelper>::type;\n\n// Finds the result type of invoking a function with the wrapped types of a pack of Expecteds.\ntemplate \nusing ResultType = decltype(Declval()(Declval().value()...));\n\ntemplate \nusing ErrorResultType = UnexpectedType()(Declval().error()...))>;\n\n// Empty struct for representing an object with only one possible value (itself). This can be used\n// for speciallizing on void types where void would not compile because it is not a valid type.\n// NOTE: GCC9 has a bug where it cannot evaluate the destructor of an empty struct, so put a dummy\n// byte in to pass the compiler warnings. All empty structs are always considered non-zero in size\n// in C++ anyway, and these are functionally equivalent for use with Expected.\n// https://www.stroustrup.com/bs_faq2.html#sizeof-empty\nstruct Unit { byte dummy; };\n\n// If T is already Expected, keep as Expected, otherwise wrap as Expected\ntemplate \nstruct FlattenExpectedHelper : TypeIdentity> {};\n\ntemplate \nstruct FlattenExpectedHelper, E> : TypeIdentity> {};\n\ntemplate \nstruct FlattenExpectedHelper&, E>\n: TypeIdentity, E>> {};\n\ntemplate \nstruct FlattenExpectedHelper&, E>\n: TypeIdentity, E>> {};\n\ntemplate \nusing FlattenExpected = typename FlattenExpectedHelper::type;\n\n// Helper for specializing on variadic parameter packs\ntemplate struct Pack {};\n\n// Checks if a functor is callable with an Expected value.\ntemplate \nstruct IsCallableHelper : FalseType {};\n\ntemplate \nstruct IsCallableHelper, void_t>> : TrueType {};\n\ntemplate \nstruct IsCallable : IsCallableHelper> {};\n\ntemplate \nconstexpr bool IsCallable_v = IsCallable::value;\n\n// Checks if a functor is callable with an Expected value.\ntemplate \nstruct IsErrorCallableHelper : FalseType {};\n\ntemplate \nstruct IsErrorCallableHelper, void_t>> : TrueType {};\n\ntemplate \nstruct IsErrorCallable : IsErrorCallableHelper> {};\n\ntemplate \nconstexpr bool IsErrorCallable_v = IsErrorCallable::value;\n\n// Maps the values with the given functor. If F returns an Expected, it returns the Expected type\n// directly, otherwise it constructs a new Expected.\ntemplate \nauto FunctorMap(F&& func, Args&&... expected) ->\n EnableIf_t>,\n FlattenExpected, ErrorTypeOr>> {\n return std::forward(func)(std::forward(expected).value()...);\n}\n\n// Maps the values with the given void functor. Returns Expected.\ntemplate \nauto FunctorMap(F&& func, Args&&... expected) ->\n EnableIf_t>, Expected>> {\n std::forward(func)(std::forward(expected).value()...);\n return {};\n}\n\n// Maps the error values with the given function. If F returns an Unexpected, it returns the\n// Unexpected type directly, otherwise it constructs a new Unexpected.\ntemplate \nExpected, ErrorResultType> FunctorMapError(F&& func, E&& expected) {\n using R = Unexpected>;\n return R{std::forward(func)(std::forward(expected).error())};\n}\n\ntemplate \nExpected> FunctorMapError(F&& func) {\n using R = Unexpected>;\n return R{std::forward(func)()};\n}\n\n// Base class for all operations of Expected, not directly related to setting or creating the value\n// type T into the underlying byte buffer.\ntemplate \nclass ExpectedBase {\n private:\n static_assert(!IsVoid_v, \"ExpectedBase cannot wrap void types\");\n static_assert(!IsVoid_v, \"ExpectedBase cannot wrap void types\");\n static_assert(!IsReference_v, \"ExpectedBase cannot wrap reference types\");\n static_assert(!IsReference_v, \"ExpectedBase cannot wrap reference types\");\n\n template \n using EnableIfMappable_t =\n EnableIf_t, decltype(FunctorMap(Declval(), Declval()))>;\n\n template \n using EnableIfNonaryMappable_t =\n EnableIf_t && !IsCallable_v, FlattenExpected, E>>;\n\n template \n using EnableIfMappableError_t =\n EnableIf_t, decltype(FunctorMapError(Declval(), Declval()))>;\n\n template \n using EnableIfNonaryMappableError_t =\n EnableIf_t && !IsErrorCallable_v,\n Expected>>;\n\n public:\n ///-----------------------------------------------------------------------------------------------\n /// Constructors\n ///-----------------------------------------------------------------------------------------------\n constexpr ExpectedBase(const ExpectedBase& other) { constructFrom(other); }\n constexpr ExpectedBase(ExpectedBase&& other) { constructFrom(std::move(other)); }\n\n // Construction from convertible error types\n template \n explicit constexpr ExpectedBase(const ExpectedBase& other) {\n static_assert(IsConvertible_v,\n \"Cannot construct Expected from type with unconvertible error type.\");\n constructFrom(other);\n }\n\n template \n explicit constexpr ExpectedBase(ExpectedBase&& other) {\n static_assert(IsConvertible_v,\n \"Cannot construct Expected from type with unconvertible error type.\");\n constructFrom(std::move(other));\n }\n\n template \n constexpr ExpectedBase(const Unexpected& error, const char* error_message = \"\")\n : is_error_{true}, error_message_{error_message} {\n static_assert(IsConvertible_v,\n \"Cannot construct Unexpected from type with unconvertible error type.\");\n InplaceConstruct>(buffer_, error.value());\n }\n\n template \n constexpr ExpectedBase(Unexpected&& error, const char* error_message = \"\")\n : is_error_{true}, error_message_{error_message} {\n static_assert(IsConvertible_v,\n \"Cannot construct Unexpected from type with unconvertible error type.\");\n InplaceConstruct>(buffer_, std::move(error.value()));\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Destructor\n ///-----------------------------------------------------------------------------------------------\n ~ExpectedBase() { destruct(); }\n\n ///-----------------------------------------------------------------------------------------------\n /// Assignment\n ///-----------------------------------------------------------------------------------------------\n ExpectedBase& operator=(const ExpectedBase& other) {\n destruct();\n constructFrom(other);\n return *this;\n }\n\n ExpectedBase& operator=(ExpectedBase&& other) {\n destruct();\n constructFrom(std::move(other));\n return *this;\n }\n\n template \n ExpectedBase& operator=(const Unexpected& error) {\n destruct();\n is_error_ = true;\n InplaceConstruct>(buffer_, error);\n return *this;\n }\n\n template \n ExpectedBase& operator=(Unexpected&& error) {\n destruct();\n is_error_ = true;\n InplaceConstruct>(buffer_, std::move(error));\n return *this;\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Observers\n ///-----------------------------------------------------------------------------------------------\n template , class D = const Derived>\n constexpr EnableIf_t, RemoveReference_t()->value())>*>\n operator->() const { return &(derived()->value()); }\n\n template , class D = Derived>\n constexpr EnableIf_t, RemoveReference_t()->value())>*>\n operator->() { return &(derived()->value()); }\n\n template >\n constexpr EnableIf_t, const V&>\n operator*() const& { return derived()->value(); }\n\n template >\n constexpr EnableIf_t, V&>\n operator*() & { return derived()->value(); }\n\n template , EnableIf_t, void*> = nullptr>\n constexpr decltype(auto) operator*() const&& { return std::move(derived())->value(); }\n\n template , EnableIf_t, void*> = nullptr>\n constexpr decltype(auto) operator*() && { return std::move(derived())->value(); }\n\n template , EnableIf_t, void*> = nullptr>\n constexpr V value_or(U&& default_value) const& {\n return has_value() ? derived()->value() : std::forward(default_value);\n }\n\n template , EnableIf_t, void*> = nullptr>\n constexpr V value_or(U&& default_value) && {\n return has_value() ? std::move(derived())->value() : std::forward(default_value);\n }\n\n constexpr bool has_value() const { return !is_error_; }\n constexpr explicit operator bool() const { return !is_error_; }\n\n constexpr const E& error() const& { return unexpected().value(); }\n constexpr E& error() & { return unexpected().value(); }\n constexpr E&& error() && { return std::move(unexpected()).value(); }\n\n constexpr const char* get_error_message() {\n GXF_ASSERT(is_error_, \"Expected does not have an error. Check before accessing.\");\n return error_message_;\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Logging\n ///-----------------------------------------------------------------------------------------------\n // Logging helper functions if this contains an error value.\n template \n constexpr const Derived& log_error(Args&&... args) const& {\n if (is_error_) { GXF_LOG_ERROR(std::forward(args)...); }\n return static_cast(*this);\n }\n template \n constexpr Derived& log_error(Args&&... args) & {\n if (is_error_) { GXF_LOG_ERROR(std::forward(args)...); }\n return static_cast(*this);\n }\n template \n constexpr Derived&& log_error(Args&&... args) && {\n // GCC is not able to do format security validation when the string is coming from a\n // variadic template, even if the string is originally a char*\n // ignore this warning until a more recent GCC version fixes this behavior\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wformat-security\"\n if (is_error_) { GXF_LOG_ERROR(std::forward(args)...); }\n#pragma GCC diagnostic pop\n return static_cast(std::move(*this));\n }\n\n template \n constexpr const Derived& log_warning(Args&&... args) const& {\n if (is_error_) { GXF_LOG_WARNING(std::forward(args)...); }\n return static_cast(*this);\n }\n template \n constexpr Derived& log_warning(Args&&... args) & {\n if (is_error_) { GXF_LOG_WARNING(std::forward(args)...); }\n return static_cast(*this);\n }\n template \n constexpr Derived&& log_warning(Args&&... args) && {\n if (is_error_) { GXF_LOG_WARNING(std::forward(args)...); }\n return static_cast(std::move(*this));\n }\n\n template \n constexpr const Derived& log_info(Args&&... args) const& {\n if (is_error_) { GXF_LOG_INFO(std::forward(args)...); }\n return static_cast(*this);\n }\n template \n constexpr Derived& log_info(Args&&... args) & {\n if (is_error_) { GXF_LOG_INFO(std::forward(args)...); }\n return static_cast(*this);\n }\n template \n constexpr Derived&& log_info(Args&&... args) && {\n if (is_error_) { GXF_LOG_INFO(std::forward(args)...); }\n return static_cast(std::move(*this));\n }\n\n template \n constexpr const Derived& log_debug(Args&&... args) const& {\n if (is_error_) { GXF_LOG_DEBUG(std::forward(args)...); }\n return static_cast(*this);\n }\n template \n constexpr Derived& log_debug(Args&&... args) & {\n if (is_error_) { GXF_LOG_DEBUG(std::forward(args)...); }\n return static_cast(*this);\n }\n template \n constexpr Derived&& log_debug(Args&&... args) && {\n if (is_error_) { GXF_LOG_DEBUG(std::forward(args)...); }\n return static_cast(std::move(*this));\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Substitute\n ///-----------------------------------------------------------------------------------------------\n // When this expected does not contain an error an expected with the given value 'next' is\n // created and returned, otherwise an unexpected with the error is returned.\n template \n constexpr FlattenExpected substitute(U next) const& {\n return has_value() ? FlattenExpected{std::forward(next)} : unexpected();\n }\n\n template \n constexpr FlattenExpected substitute(U next) && {\n return has_value() ? FlattenExpected{std::forward(next)} : std::move(unexpected());\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Substitute Error\n ///-----------------------------------------------------------------------------------------------\n template \n constexpr Expected, G> substitute_error(G new_error) const& {\n using R = Expected, G>;\n return is_error_ ? R{Unexpected{new_error}} : R{*ValuePointer(buffer_)};\n }\n\n template \n constexpr Expected, G> substitute_error(G new_error) && {\n using R = Expected, G>;\n return is_error_ ? R{Unexpected{new_error}} : R{std::move(*ValuePointer(buffer_))};\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Unary Free Functor Map\n ///-----------------------------------------------------------------------------------------------\n // If in error the error is returned, otherwise the value is mapped with the given functor and\n // the result is returned.\n template \n constexpr EnableIfMappable_t map(F&& func) & {\n return has_value() ? FunctorMap(std::forward(func), *derived()) : unexpected();\n }\n\n template \n constexpr EnableIfMappable_t map(F&& func) const& {\n return has_value() ? FunctorMap(std::forward(func), *derived()) : unexpected();\n }\n\n template \n constexpr EnableIfMappable_t map(F&& func) && {\n return has_value() ? FunctorMap(std::forward(func), std::move(*derived()))\n : std::move(unexpected());\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Unary Free Functor Map Error\n ///-----------------------------------------------------------------------------------------------\n // If has value the value is returned, otherwise the error is mapped with the given functor and\n // the result is returned.\n template \n constexpr EnableIfMappableError_t map_error(F&& func) & {\n using R = Expected, ErrorResultType>;\n return is_error_ ? FunctorMapError(std::forward(func), *derived())\n : R{*ValuePointer(buffer_)};\n }\n\n template \n constexpr EnableIfMappableError_t map_error(F&& func) const& {\n using R = Expected, ErrorResultType>;\n return is_error_ ? FunctorMapError(std::forward(func), *derived())\n : R{*ValuePointer(buffer_)};\n }\n\n template \n constexpr EnableIfMappableError_t map_error(F&& func) && {\n using R = Expected, ErrorResultType>;\n return is_error_ ? FunctorMapError(std::forward(func), std::move(*derived()))\n : R{std::move(*ValuePointer(buffer_))};\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Nonary Free Functor Map\n ///-----------------------------------------------------------------------------------------------\n // If in error the error is returned, otherwise the given functor is called with no arguments and\n // the result is returned.\n template \n constexpr EnableIfNonaryMappable_t map(F&& func) const& {\n return has_value() ? FunctorMap(std::forward(func)) : unexpected();\n }\n\n template \n constexpr EnableIfNonaryMappable_t map(F&& func) && {\n return has_value() ? FunctorMap(std::forward(func)) : std::move(unexpected());\n }\n\n template \n constexpr FlattenExpected, E> and_then(F&& func) const& {\n return has_value() ? FunctorMap(std::forward(func)) : unexpected();\n }\n template \n constexpr FlattenExpected, E> and_then(F&& func) && {\n return has_value() ? FunctorMap(std::forward(func)) : std::move(unexpected());\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Nonary Free Functor Map Error\n ///-----------------------------------------------------------------------------------------------\n // If has value the value is returned, otherwise the given functor is called with no arguments and\n // the result is returned.\n template \n constexpr EnableIfNonaryMappableError_t map_error(F&& func) const& {\n static_assert(IsErrorCallable_v);\n static_assert(!IsErrorCallable_v);\n using R = Expected, ErrorResultType>;\n return is_error_ ? FunctorMapError(std::forward(func)) : R{*ValuePointer(buffer_)};\n }\n\n template \n constexpr EnableIfNonaryMappableError_t map_error(F&& func) && {\n using R = Expected, ErrorResultType>;\n return is_error_ ? FunctorMapError(std::forward(func))\n : R{std::move(*ValuePointer(buffer_))};\n }\n\n template \n constexpr Expected, ErrorResultType> and_then_error(F&& func) const& {\n using R = Expected, ErrorResultType>;\n return is_error_ ? FunctorMapError(std::forward(func)) : R{*ValuePointer(buffer_)};\n }\n\n template \n constexpr Expected, ErrorResultType> and_then_error(F&& func) && {\n using R = Expected, ErrorResultType>;\n return is_error_ ? FunctorMapError(std::forward(func))\n : R{std::move(*ValuePointer(buffer_))};\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Member Variable Map\n ///-----------------------------------------------------------------------------------------------\n template \n constexpr FlattenExpected map(R U::* ptr) & {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n // NOTE: We explicitly declare the return type of the lambda to allow capturing of member by\n // mutable reference, otherwise a lambda will always return a copy.\n auto func = [&](ValueType& a) -> decltype(auto) { return a.*ptr; };\n return has_value() ? FunctorMap(func, *derived()) : unexpected();\n }\n\n template \n constexpr FlattenExpected map(R U::* ptr) const& {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n auto func = [&](const ValueType& a) -> decltype(auto) { return a.*ptr; };\n return has_value() ? FunctorMap(func, *derived()) : unexpected();\n }\n\n template \n constexpr FlattenExpected, E> map(R U::* ptr) && {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n // NOTE: there is a subtle distinction here. If we want to get access to a member variable\n // from an rvalue context, we MUST make a copy, since we cannot guarantee the reference will\n // still be valid after destruction of the temporary.\n auto func = [&](ValueType&& a) { return a.*ptr; };\n return has_value() ? FunctorMap(func, std::move(*derived())) : unexpected();\n }\n\n template \n constexpr FlattenExpected, E> map(R U::* ptr) const&& {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n auto func = [&](const ValueType&& a) { return a.*ptr; };\n return has_value() ? FunctorMap(func, std::move(*derived())) : unexpected();\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Member Function Map\n ///-----------------------------------------------------------------------------------------------\n template \n constexpr FlattenExpected map(R (U::* ptr)(Args...), Args&&... args) {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n auto func = [&](U& a) { return (a.*ptr)(std::forward(args)...); };\n return has_value() ? FunctorMap(func, *derived()) : unexpected();\n }\n\n template \n constexpr FlattenExpected map(R (U::* ptr)(Args...) & , Args&&... args) & {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n auto func = [&](U& a) { return (a.*ptr)(std::forward(args)...); };\n return has_value() ? FunctorMap(func, *derived()) : unexpected();\n }\n\n template \n constexpr FlattenExpected map(R (U::* ptr)(Args...) &&, Args&&... args) && {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n auto func = [&](U&& a) { return (std::move(a).*ptr)(std::forward(args)...); };\n return has_value() ? FunctorMap(func, std::move(*derived())) : unexpected();\n }\n\n template \n constexpr FlattenExpected map(R (U::* ptr)(Args...) const, Args&&... args) const {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n auto func = [&](const U& a) { return (a.*ptr)(std::forward(args)...); };\n return has_value() ? FunctorMap(func, *derived()) : unexpected();\n }\n\n template \n constexpr FlattenExpected map(R (U::* ptr)(Args...) const&, Args&&... args) const& {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n auto func = [&](const U& a) { return (a.*ptr)(std::forward(args)...); };\n return has_value() ? FunctorMap(func, *derived()) : unexpected();\n }\n\n template \n constexpr FlattenExpected map(R (U::* ptr)(Args...) const&&, Args&&... args) const&& {\n static_assert(IsSame_v>>,\n \"received pointer-to-member that is not of type T.\");\n auto func = [&](const U&& a) { return (std::move(a).*ptr)(std::forward(args)...); };\n return has_value() ? FunctorMap(func, std::move(*derived())) : unexpected();\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Assign Value\n ///-----------------------------------------------------------------------------------------------\n // Assigns the value of an expected directly to a concrete instance with perfect forwarding.\n template \n constexpr Expected assign_to(U& value) const& {\n static_assert(IsAssignable_v&>,\n \"Argument Type is not assignable with Expected Type (const T&)\");\n auto assign = [&](const ValueType& derived) { value = derived; };\n return has_value() ? FunctorMap(assign, *derived()) : unexpected();\n }\n\n template \n constexpr Expected assign_to(U& value) && {\n static_assert(IsAssignable_v&&>,\n \"Argument Type is not assignable with Expected Type (T&&)\");\n auto move_assign = [&](ValueType&& derived) { value = std::move(derived); };\n return has_value() ? FunctorMap(move_assign, std::move(*derived())) : std::move(unexpected());\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Guard\n ///-----------------------------------------------------------------------------------------------\n\n template \n constexpr Expected, E> guard(P&& pred, E&& new_error) const& {\n if (is_error_) { return unexpected(); }\n return pred(derived()->value()) ? *derived() : Unexpected{new_error};\n }\n\n template \n constexpr Expected, E> guard(P&& pred, E&& new_error) && {\n if (is_error_) { return std::move(unexpected()); }\n return pred(derived()->value()) ? std::move(*derived()) : Unexpected{new_error};\n }\n\n ///-----------------------------------------------------------------------------------------------\n /// Ignore Error\n ///-----------------------------------------------------------------------------------------------\n\n template \n constexpr Expected, E> ignore_error(U&& next) const& {\n return has_value() ? *derived() : std::forward(next);\n }\n\n template \n constexpr Expected, E> ignore_error(U&& next) && {\n return has_value() ? std::move(*derived()) : std::forward(next);\n }\n\n constexpr Expected ignore_error() const { return {}; }\n\n protected:\n // Allow other Expected classes access to `unexpected` getters.\n template \n friend class ExpectedBase;\n\n // Protected default constructor so derived types can write custom initializers.\n ExpectedBase() = default;\n\n // Protected Value constructor so Derived types can convert to stored types\n template , void*> = nullptr>\n constexpr ExpectedBase(Args&&... args) {\n constructValueFrom(std::forward(args)...);\n }\n\n // Unexpected accessors to skip extra construction calls when not needed.\n constexpr const Unexpected& unexpected() const& {\n GXF_ASSERT(is_error_, \"Expected does not have an error. Check before accessing.\");\n return *ValuePointer>(buffer_);\n }\n\n constexpr Unexpected& unexpected() & {\n GXF_ASSERT(is_error_, \"Expected does not have an error. Check before accessing.\");\n return *ValuePointer>(buffer_);\n }\n\n constexpr Unexpected&& unexpected() && {\n GXF_ASSERT(is_error_, \"Expected does not have an error. Check before accessing.\");\n return std::move(*ValuePointer>(buffer_));\n }\n\n // Returns a pointer to the derived type for accessing value result in supported specializations.\n constexpr const Derived* derived() const { return static_cast(this); }\n constexpr Derived* derived() { return static_cast(this); }\n\n ///-----------------------------------------------------------------------------------------------\n /// Construction Helpers\n ///-----------------------------------------------------------------------------------------------\n // Construct a new object in allocated buffer.\n template \n constexpr void constructFrom(const ExpectedBase& other) {\n other.has_value() ? constructValueFrom(other) : constructErrorFrom(other);\n }\n\n // Move construct a new object in allocated buffer.\n template \n constexpr void constructFrom(ExpectedBase&& other) {\n other.has_value() ? constructValueFrom(std::move(other)) : constructErrorFrom(std::move(other));\n }\n\n template \n constexpr void constructErrorFrom(const ExpectedBase& other) {\n is_error_ = true;\n InplaceCopyConstruct(buffer_, *ValuePointer>(other.buffer_));\n }\n\n template \n constexpr void constructErrorFrom(ExpectedBase&& other) {\n is_error_ = true;\n InplaceMoveConstruct(buffer_, std::move(*ValuePointer>(other.buffer_)));\n }\n\n template \n constexpr void constructValueFrom(const ExpectedBase& other) {\n is_error_ = false;\n InplaceCopyConstruct(buffer_, *ValuePointer(other.buffer_));\n }\n\n template \n constexpr void constructValueFrom(ExpectedBase&& other) {\n is_error_ = false;\n InplaceConstruct(buffer_, std::move(*ValuePointer(other.buffer_)));\n }\n\n template \n void constructValueFrom(Args&&... args) {\n is_error_ = false;\n InplaceConstruct(buffer_, std::forward(args)...);\n }\n\n // Call the destructor for the current object explicitly\n constexpr void destruct() {\n has_value() ? Destruct(buffer_) : Destruct>(buffer_);\n }\n\n bool is_error_ = true;\n const char* error_message_{};\n static constexpr uint32_t kAlign =\n (alignof(Unexpected) < alignof(T)) ? alignof(T) : alignof(Unexpected);\n static constexpr uint32_t kSize =\n (sizeof(Unexpected) < sizeof(T)) ? sizeof(T) : sizeof(Unexpected);\n alignas(kAlign) byte buffer_[kSize] = {0};\n};\n} // namespace detail\n\n///-------------------------------------------------------------------------------------------------\n// Expected Implementation\n///-------------------------------------------------------------------------------------------------\n// Default instance for Expected types.\ntemplate \nclass Expected : public detail::ExpectedBase> {\n public:\n using detail::ExpectedBase::ExpectedBase;\n\n // Enable implicit construction of Move-Only types\n constexpr Expected(T&& value) : detail::ExpectedBase(std::move(value)) {}\n\n template && IsConvertible_v>* = nullptr>\n constexpr Expected(U&& value) : detail::ExpectedBase(std::forward(value)) {}\n\n template && !IsConvertible_v>* = nullptr>\n explicit constexpr Expected(U&& value)\n : detail::ExpectedBase(std::forward(value)) {}\n\n template , void*> = nullptr>\n explicit constexpr Expected(Args&&... args)\n : detail::ExpectedBase(std::forward(args)...) {}\n\n template && IsConvertible_v>* = nullptr>\n constexpr Expected(const Expected& other) {\n other.has_value() ? this->constructValueFrom(other.value()) : this->constructErrorFrom(other);\n }\n\n template && !IsConvertible_v>* = nullptr>\n explicit constexpr Expected(const Expected& other) {\n other.has_value() ? this->constructValueFrom(other.value()) : this->constructErrorFrom(other);\n }\n\n template && IsConvertible_v>* = nullptr>\n constexpr Expected(Expected&& other) {\n other.has_value() ? this->constructValueFrom(std::move(other.value()))\n : this->constructErrorFrom(std::move(other));\n }\n\n template && !IsConvertible_v>* = nullptr>\n explicit constexpr Expected(Expected&& other) {\n other.has_value() ? this->constructValueFrom(std::move(other.value()))\n : this->constructErrorFrom(std::move(other));\n }\n\n template && IsConvertible_v>* = nullptr>\n constexpr Expected& operator=(U&& value) {\n this->destruct();\n this->constructValueFrom(std::forward(value));\n return *this;\n }\n\n template \n T& replace(Args&&... args) {\n static_assert(IsConstructible_v,\n \"T cannot be constructed with the provide argument types.\");\n this->destruct();\n this->constructValueFrom(std::forward(args)...);\n return value();\n }\n\n constexpr const T& value() const& {\n GXF_ASSERT(this->has_value(), \"Expected does not have a value. Check before accessing.\");\n return *ValuePointer(this->buffer_);\n }\n\n constexpr T& value() & {\n GXF_ASSERT(this->has_value(), \"Expected does not have a value. Check before accessing.\");\n return *ValuePointer(this->buffer_);\n }\n\n constexpr const T&& value() const&& {\n GXF_ASSERT(this->has_value(), \"Expected does not have a value. Check before accessing.\");\n return std::move(*ValuePointer(this->buffer_));\n }\n\n constexpr T&& value() && {\n GXF_ASSERT(this->has_value(), \"Expected does not have a value. Check before accessing.\");\n return std::move(*ValuePointer(this->buffer_));\n }\n};\n\n///-------------------------------------------------------------------------------------------------\n/// Expected of Reference Implementation\n///-------------------------------------------------------------------------------------------------\n// Specialization of Expected for references.\ntemplate \nclass Expected : public detail::ExpectedBase> {\n private:\n template \n struct IsExpectedConvertible : FalseType {};\n\n template \n struct IsExpectedConvertible().value())>>\n : IsConvertible().value()), T&> {};\n\n template \n static constexpr bool IsExpectedConvertible_v =\n detail::IsExpected_v && IsExpectedConvertible::value;\n\n public:\n using detail::ExpectedBase::ExpectedBase;\n\n template , void*> = nullptr>\n constexpr Expected(U&& value) : detail::ExpectedBase(&std::forward(value)) {}\n\n template , void*> = nullptr>\n constexpr Expected(U&& other) {\n other.has_value() ? this->constructValueFrom(&std::forward(other).value())\n : this->constructErrorFrom(std::forward(other));\n }\n\n constexpr T& value() const {\n GXF_ASSERT(this->has_value(), \"Expected does not have a value. Check before accessing.\");\n return **ValuePointer(this->buffer_);\n }\n};\n///-------------------------------------------------------------------------------------------------\n/// Expected of Void Implementation\n///-------------------------------------------------------------------------------------------------\n// Specialization of Expected for void. This is essentially an std::optional.\ntemplate \nclass Expected : public detail::ExpectedBase> {\n public:\n using detail::ExpectedBase::ExpectedBase;\n\n constexpr Expected() : detail::ExpectedBase(detail::Unit{}) {}\n\n // Constructor that allows assigning an Expected with the same error type to an Expected\n template \n explicit constexpr Expected(const Expected& other) {\n other.has_value() ? this->constructValueFrom() : this->constructErrorFrom(other);\n }\n\n // Constructor that allows assigning an Expected with the same error type to an Expected\n template \n explicit constexpr Expected(Expected&& other) {\n other.has_value() ? this->constructValueFrom() : this->constructErrorFrom(std::move(other));\n }\n\n // Combines two expected value taking the first error.\n template \n Expected& operator&=(const Expected& other) {\n *this = *this & other;\n return *this;\n }\n\n // Combines two expected value taking the last success.\n template \n Expected& operator|=(const Expected& other) {\n *this = *this | other;\n return *this;\n }\n};\n\n///-------------------------------------------------------------------------------------------------\n/// Utility Functions\n///-------------------------------------------------------------------------------------------------\n// Checks if all Expected values are not in error. If in error, return the first error found.\ntemplate \nExpected AllOf(const Expected& expected) {\n return Expected{expected};\n}\n\n// Checks if all Expected values are not in error. If in error, return the first error found.\ntemplate \nExpected AllOf(const Expected& expected, const Expected&... others) {\n return expected & AllOf(others...);\n}\n\n// Checks if all the Arguments are of type Expected. If so, unwraps them and calls\n// the function object F with the unwrapped arguments. Otherwise, return an Unexpected with\n// the first error value found in the argument list.\ntemplate \nauto Apply(F&& func, Args&&... args) -> EnableIf_t<\n Conjunction_v...>, decltype(detail::FunctorMap(func, args...)) > {\n const auto all_valid = AllOf(std::forward(args)...);\n if (!all_valid) { return Unexpected>(all_valid.error()); }\n return detail::FunctorMap(std::forward(func), std::forward(args)...);\n}\n\n///-------------------------------------------------------------------------------------------------\n/// Comparison Operators\n///-------------------------------------------------------------------------------------------------\ntemplate \nconstexpr bool operator==(const Expected& lhs, const Expected& rhs) {\n return ( lhs && rhs && (lhs.value() == rhs.value())) ||\n (!lhs && !rhs && (lhs.error() == rhs.error()));\n}\ntemplate \nconstexpr bool operator==(const Expected& lhs, const U& rhs) {\n return lhs && (*lhs == rhs);\n}\ntemplate \nconstexpr bool operator==(const U& lhs, const Expected& rhs) {\n return rhs && (lhs == *rhs);\n}\ntemplate \nconstexpr bool operator==(const Expected& lhs, const Unexpected& rhs) {\n return !lhs && (lhs.error() == rhs.value());\n}\ntemplate \nconstexpr bool operator==(const Unexpected& lhs, const Expected& rhs) {\n return !rhs && (lhs.value() == rhs.error());\n}\ntemplate \nconstexpr bool operator==(const Unexpected& lhs, const Unexpected& rhs) {\n return lhs.value() == rhs.value();\n}\n\n// All inequality operators are defined in terms of negated equality\ntemplate \nconstexpr bool operator!=(const Expected& lhs, const Expected& rhs) {\n return !(lhs == rhs);\n}\ntemplate \nconstexpr bool operator!=(const Expected& lhs, const U& rhs) {\n return !(lhs == rhs);\n}\ntemplate \nconstexpr bool operator!=(const U& lhs, const Expected& rhs) {\n return !(lhs == rhs);\n}\ntemplate \nconstexpr bool operator!=(const Unexpected& lhs, const Unexpected& rhs) {\n return !(lhs == rhs);\n}\n\n///-------------------------------------------------------------------------------------------------\n/// Binary Logical Operators\n///-------------------------------------------------------------------------------------------------\n// Combines two expected value taking the first error.\ntemplate \nExpected operator&(const Expected& lhs, const Expected& rhs) {\n return !lhs ? Expected{lhs} : Expected{rhs};\n}\n\n// Combines two expected value taking the last success.\ntemplate \nExpected operator|(const Expected& lhs, const Expected& rhs) {\n return rhs ? Expected{rhs} : Expected{lhs};\n}\n\n///-------------------------------------------------------------------------------------------------\n/// Binary Arithmetic Operators\n///-------------------------------------------------------------------------------------------------\n// Arithmetic operator+ for values stored in expected values. Returns either the computed value\n// or the first unexpected among lhs and rhs.\ntemplate \nExpected operator+(const Expected& lhs, const Expected& rhs) {\n return Apply([](const V& lhs, const V& rhs) { return lhs + rhs; }, lhs, rhs);\n}\n\ntemplate \nExpected operator+(const Expected& lhs, const V& rhs) {\n return lhs.map([&](const V& value) { return value + rhs; });\n}\n\ntemplate \nExpected operator+(const V& lhs, const Expected& rhs) {\n return rhs.map([&](const V& value) { return lhs + value; });\n}\n\n// Arithmetic operator- for values stored in expected values. Returns either the computed value\n// or the first unexpected among lhs and rhs.\ntemplate \nExpected operator-(const Expected& lhs, const Expected& rhs) {\n return Apply([](const V& lhs, const V& rhs) { return lhs - rhs; }, lhs, rhs);\n}\n\ntemplate \nExpected operator-(const Expected& lhs, const V& rhs) {\n return lhs.map([&](const V& value) { return value - rhs; });\n}\n\ntemplate \nExpected operator-(const V& lhs, const Expected& rhs) {\n return rhs.map([&](const V& value) { return lhs - value; });\n}\n\n// Arithmetic operator* for values stored in expected values. Returns either the computed value\n// or the first unexpected among lhs and rhs.\ntemplate \nExpected operator*(const Expected& lhs, const Expected& rhs) {\n return Apply([](const V& lhs, const V& rhs) { return lhs * rhs; }, lhs, rhs);\n}\n\ntemplate \nExpected operator*(const Expected& lhs, const V& rhs) {\n return lhs.map([&](const V& value) { return value * rhs; });\n}\n\ntemplate \nExpected operator*(const V& lhs, const Expected& rhs) {\n return rhs.map([&](const V& value) { return lhs * value; });\n}\n\n// Arithmetic operator/ for values stored in expected values. Returns either the computed value\n// or the first unexpected among lhs and rhs.\ntemplate \nExpected operator/(const Expected& lhs, const Expected& rhs) {\n return Apply([](const V& lhs, const V& rhs) { return lhs / rhs; }, lhs, rhs);\n}\n\ntemplate \nExpected operator/(const Expected& lhs, const V& rhs) {\n return lhs.map([&](const V& value) { return value / rhs; });\n}\n\ntemplate \nExpected operator/(const V& lhs, const Expected& rhs) {\n return rhs.map([&](const V& value) { return lhs / value; });\n}\n\n// Arithmetic operator% for values stored in expected values. Returns either the computed value\n// or the first unexpected among lhs and rhs.\ntemplate \nExpected operator%(const Expected& lhs, const Expected& rhs) {\n return Apply([](const V& lhs, const V& rhs) { return lhs % rhs; }, lhs, rhs);\n}\n\ntemplate \nExpected operator%(const Expected& lhs, const V& rhs) {\n return lhs.map([&](const V& value) { return value % rhs; });\n}\n\ntemplate \nExpected operator%(const V& lhs, const Expected& rhs) {\n return rhs.map([&](const V& value) { return lhs % value; });\n}\n\n} // namespace nvidia\n\n#endif // NVIDIA_COMMON_EXPECTED_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/fixed_map.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_COMMON_FIXED_MAP_HPP_\n#define NVIDIA_GXF_COMMON_FIXED_MAP_HPP_\n\n#include \n#include \n\n#include \"common/expected.hpp\"\n#include \"common/memory_utils.hpp\"\n#include \"common/type_utils.hpp\"\n\nnamespace nvidia {\n\n// Data structure that provides similar functionality to std::unordered_map but does not dynamically\n// reallocate memory and uses Expected type for error handling instead of exceptions.\n// This container is not thread-safe.\ntemplate >\nclass FixedMap {\n public:\n template \n class Iterator;\n template \n class ReverseIterator;\n template \n using ConstIterator = Iterator;\n\n // Use STL naming convention for compatibility with STL algorithms\n using key_type = Key;\n using mapped_type = T;\n using value_type = std::pair;\n using size_type = size_t;\n using iterator = Iterator;\n using reverse_iterator = ReverseIterator;\n using const_iterator = ConstIterator;\n using const_reverse_iterator = ReverseIterator;\n\n // Custom error codes for map\n enum struct Error {\n kOutOfMemory, // Memory allocation failed\n kInvalidKey, // Key is not in container\n kDuplicateKey, // Key is already in container\n kContainerFull, // Container is full\n kInvalidIterator, // Iterator is invalid\n };\n\n // Expected type which uses class specific errors\n template \n using Expected = Expected;\n\n template \n class Iterator {\n public:\n static_assert(IsSame_v, FixedMap>);\n\n // iterator traits\n using iterator_category = std::bidirectional_iterator_tag;\n using value_type = TValue;\n using difference_type = std::ptrdiff_t;\n using pointer = TValue*;\n using reference = TValue&;\n\n constexpr Iterator() : container_{nullptr}, index_{-1} {}\n constexpr Iterator(TContainer& container, size_t start) : container_{&container}, index_{0} {\n *this += start;\n }\n\n constexpr Iterator(const Iterator& other) = default;\n constexpr Iterator(Iterator&& other) = default;\n constexpr Iterator& operator=(const Iterator& other) = default;\n constexpr Iterator& operator=(Iterator&& other) = default;\n\n constexpr Expected operator*() const {\n if (container_ == nullptr || container_->data_ == nullptr ||\n index_ < 0 || index_ >= static_cast(container_->capacity_)) {\n return Unexpected{Error::kInvalidIterator};\n }\n Bucket& bucket = container_->data_[index_];\n if (!bucket.occupied) {\n return Unexpected{Error::kInvalidIterator};\n }\n return bucket.value;\n }\n\n constexpr Iterator& operator+=(difference_type offset) {\n if (container_ == nullptr || container_->data_ == nullptr) {\n return *this;\n }\n\n while (true) {\n const Bucket& bucket = container_->data_[index_];\n if (bucket.occupied) {\n break;\n }\n index_++;\n if (index_ >= static_cast(container_->capacity_)) {\n break;\n }\n }\n\n if ((offset > 0 && index_ >= static_cast(container_->capacity_)) ||\n (offset < 0 && index_ <= 0)) {\n return *this;\n }\n\n while (offset > 0) {\n index_++;\n if (index_ >= static_cast(container_->capacity_)) {\n break;\n }\n const Bucket& bucket = container_->data_[index_];\n if (bucket.occupied) {\n offset--;\n }\n }\n\n while (offset < 0) {\n index_--;\n if (index_ <= 0) {\n break;\n }\n const Bucket& bucket = container_->data_[index_];\n if (bucket.occupied) {\n offset++;\n }\n }\n\n return *this;\n }\n constexpr Iterator& operator++() {\n *this += 1;\n return *this;\n }\n constexpr Iterator operator++(int) {\n Iterator iter = *this;\n ++(*this);\n return iter;\n }\n constexpr Iterator& operator-=(difference_type offset) {\n *this += -offset;\n return *this;\n }\n constexpr Iterator& operator--() {\n *this -= 1;\n return *this;\n }\n constexpr Iterator operator--(int) {\n Iterator iter = *this;\n --(*this);\n return iter;\n }\n\n friend constexpr Iterator operator+(Iterator a, difference_type n) {\n a += n;\n return a;\n }\n friend constexpr Iterator operator+(difference_type n, Iterator a) {\n return a + n;\n }\n friend constexpr Iterator operator-(Iterator a, difference_type n) {\n a -= n;\n return a;\n }\n friend constexpr difference_type operator-(const Iterator& a, const Iterator& b) {\n return a.index_ - b.index_;\n }\n friend constexpr bool operator==(const Iterator& a, const Iterator& b) {\n return a.container_ == b.container_ && a.index_ == b.index_;\n }\n friend constexpr bool operator!=(const Iterator& a, const Iterator& b) {\n return !(a == b);\n }\n\n private:\n // Container pointer\n TContainer* container_;\n // Iterator index\n difference_type index_;\n };\n\n template \n class ReverseIterator {\n public:\n static_assert(IsSame_v || IsSame_v);\n\n using TValue = typename TIterator::value_type;\n // iterator traits\n using iterator_category = std::bidirectional_iterator_tag;\n using value_type = TValue;\n using difference_type = std::ptrdiff_t;\n using pointer = TValue*;\n using reference = TValue&;\n\n constexpr explicit ReverseIterator() : iter_{} {}\n constexpr explicit ReverseIterator(TIterator iter) : iter_{iter} {}\n\n constexpr ReverseIterator(const ReverseIterator& other) = default;\n constexpr ReverseIterator(ReverseIterator&& other) = default;\n constexpr ReverseIterator& operator=(const ReverseIterator& other) = default;\n constexpr ReverseIterator& operator=(ReverseIterator&& other) = default;\n\n constexpr TIterator base() const { return iter_; }\n\n constexpr Expected operator*() const { return *std::prev(iter_); }\n\n constexpr ReverseIterator& operator+=(difference_type offset) {\n iter_ -= offset;\n return *this;\n }\n constexpr ReverseIterator& operator++() {\n iter_ -= 1;\n return *this;\n }\n constexpr ReverseIterator operator++(int) {\n ReverseIterator iter = *this;\n ++(*this);\n return iter;\n }\n constexpr ReverseIterator& operator-=(difference_type offset) {\n iter_ += offset;\n return *this;\n }\n constexpr ReverseIterator& operator--() {\n iter_ += 1;\n return *this;\n }\n constexpr ReverseIterator operator--(int) {\n ReverseIterator iter = *this;\n --(*this);\n return iter;\n }\n\n friend constexpr ReverseIterator operator+(ReverseIterator a, difference_type n) {\n return ReverseIterator(a.iter_ - n);\n }\n friend constexpr ReverseIterator operator+(difference_type n, ReverseIterator a) {\n return ReverseIterator(a.iter_ - n);\n }\n friend constexpr ReverseIterator operator-(ReverseIterator a, difference_type n) {\n return ReverseIterator(a.iter_ + n);\n }\n friend constexpr difference_type operator-(const ReverseIterator& a, const ReverseIterator& b) {\n return b.iter_ - a.iter_;\n }\n friend constexpr bool operator==(const ReverseIterator& a, const ReverseIterator& b) {\n return a.iter_ == b.iter_;\n }\n friend constexpr bool operator!=(const ReverseIterator& a, const ReverseIterator& b) {\n return !(a == b);\n }\n\n private:\n /// Random-access iterator\n TIterator iter_;\n };\n\n FixedMap() : data_{nullptr}, capacity_{0}, size_{0} {}\n FixedMap(const FixedMap& other) = delete;\n FixedMap(FixedMap&& other) : data_{nullptr}, capacity_{0}, size_{0} { *this = std::move(other); }\n FixedMap& operator=(const FixedMap& other) = delete;\n FixedMap& operator=(FixedMap&& other) {\n if (this != &other) {\n std::swap(data_, other.data_);\n std::swap(capacity_, other.capacity_);\n std::swap(size_, other.size_);\n }\n return *this;\n }\n ~FixedMap() {\n clear();\n DeallocateArray(data_);\n }\n\n bool operator==(const FixedMap& other) const {\n if ((capacity_ != other.capacity_) || (size_ != other.size_)) {\n return false;\n }\n for (size_type i = 0; i < capacity_; i++) {\n if (data_[i].occupied) {\n if (!other.data_[i].occupied || (data_[i].value != other.data_[i].value)) {\n return false;\n }\n }\n }\n return true;\n }\n bool operator!=(const FixedMap& other) const { return !(*this == other); }\n\n constexpr iterator begin() { return iterator(*this, 0); }\n constexpr iterator end() { return iterator(*this, size_); }\n constexpr reverse_iterator rbegin() { return reverse_iterator(end()); }\n constexpr reverse_iterator rend() { return reverse_iterator(begin()); }\n\n constexpr const_iterator begin() const { return cbegin(); }\n constexpr const_iterator end() const { return cend(); }\n constexpr const_reverse_iterator rbegin() const { return crbegin(); }\n constexpr const_reverse_iterator rend() const { return crend(); }\n\n constexpr const_iterator cbegin() const { return const_iterator(*this, 0); }\n constexpr const_iterator cend() const { return const_iterator(*this, size_); }\n constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }\n constexpr const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }\n\n Expected operator[](const key_type& key) {\n Bucket* bucket = findMatchingBucket(key);\n if (!bucket) {\n auto result = emplace(std::make_pair(key, mapped_type()));\n if (!result) {\n return Unexpected{result.error()};\n }\n bucket = findMatchingBucket(key);\n if (!bucket) {\n return Unexpected{Error::kInvalidKey};\n }\n }\n return bucket->value.second;\n }\n\n // Returns the number of elements the container can currently hold\n size_type capacity() const { return capacity_; }\n // Returns the number of elements in the container\n size_type size() const { return size_; }\n // Returns true if the container has no elements\n bool empty() const { return size_ == 0; }\n // Returns true if the container has reached capacity\n bool full() const { return size_ == capacity_; }\n // Returns the load factor of the container\n double load_factor() const {\n return capacity_ > 0 ? static_cast(size_) / static_cast(capacity_) : 0.0;\n }\n\n // Checks if the container has a value for the given key\n bool contains(const key_type& key) const { return findMatchingBucket(key) != nullptr; }\n\n // Returns a reference to the value at the given key\n Expected at(const key_type& key) {\n Bucket* bucket = findMatchingBucket(key);\n if (!bucket) {\n return Unexpected{Error::kInvalidKey};\n }\n return bucket->value.second;\n }\n\n // Returns a read-only reference to the value with the given key\n Expected at(const key_type& key) const {\n Bucket* bucket = findMatchingBucket(key);\n if (!bucket) {\n return Unexpected{Error::kInvalidKey};\n }\n return bucket->value.second;\n }\n\n // Update a key that is already in the map\n Expected update(const key_type& key, const mapped_type& value) {\n Bucket* bucket = findMatchingBucket(key);\n if (!bucket) { return Unexpected{Error::kInvalidKey}; }\n bucket->value.second = value;\n return kSuccess;\n }\n\n // Assigns an the value to the given key if it exists, else creates a new object\n template \n Expected insert_or_assign(Args&&... args) {\n value_type value(std::forward(args)...);\n Bucket* bucket = findMatchingBucket(value.first);\n if (bucket) {\n bucket->value.second = value.second;\n return kSuccess;\n } else {\n return emplace(std::move(value));\n }\n }\n\n // Creates a new object with the provided arguments and adds it using the given key\n template \n Expected emplace(Args&&... args) {\n value_type value(std::forward(args)...);\n if (findMatchingBucket(value.first)) {\n return Unexpected{Error::kDuplicateKey};\n }\n Bucket* bucket = findEmptyBucket(value.first);\n if (!bucket) {\n return Unexpected{Error::kContainerFull};\n }\n InplaceMoveConstruct(BytePointer(&bucket->value), std::move(value));\n bucket->occupied = true;\n size_++;\n return kSuccess;\n }\n\n // Copies the object with the given key\n Expected insert(const value_type& value) { return emplace(value); }\n // Moves the object with the given key\n Expected insert(value_type&& value) {\n return emplace(std::forward(value));\n }\n\n // Removes the object at the given key and destroys it\n Expected erase(const key_type& key) {\n Bucket* bucket = findMatchingBucket(key);\n if (!bucket) {\n return Unexpected{Error::kInvalidKey};\n }\n Destruct(BytePointer(&bucket->value));\n bucket->occupied = false;\n size_--;\n return kSuccess;\n }\n\n // Removes all objects from the vector\n void clear() {\n for (size_type i = 0; i < capacity_; i++) {\n Bucket* bucket = &data_[i];\n if (bucket->occupied) {\n Destruct(BytePointer(&bucket->value));\n bucket->occupied = false;\n }\n }\n size_ = 0;\n }\n\n // Allocates memory to hold the specified number of elements\n Expected reserve(size_type capacity) {\n if (capacity > capacity_) {\n Bucket* const temp_data = data_;\n const size_type temp_capacity = capacity_;\n const size_type temp_size = size_;\n\n data_ = AllocateArray(capacity);\n capacity_ = capacity;\n size_ = 0;\n\n if (data_ == nullptr) {\n data_ = temp_data;\n capacity_ = temp_capacity;\n size_ = temp_size;\n return Unexpected{Error::kOutOfMemory};\n }\n\n for (size_type i = 0; i < capacity_; i++) {\n data_[i].occupied = false;\n }\n\n for (size_type i = 0; i < temp_capacity; i++) {\n Bucket* bucket = &temp_data[i];\n if (bucket->occupied) {\n auto result = emplace(std::move(bucket->value));\n if (!result) {\n return Unexpected{result.error()};\n }\n }\n }\n\n DeallocateArray(temp_data);\n }\n\n return kSuccess;\n }\n\n // Copies the contents of the given map\n // Current contents are discarded\n // Fails if given map is larger than current capacity\n Expected copy_from(const FixedMap& other) {\n if (other.size_ > capacity_) {\n return Unexpected{Error::kContainerFull};\n }\n clear();\n for (size_type i = 0; i < other.capacity_; i++) {\n Bucket* bucket = &other.data_[i];\n if (bucket->occupied) {\n auto result = emplace(bucket->value.first, bucket->value.second);\n if (!result) {\n return Unexpected{result.error()};\n }\n }\n }\n return kSuccess;\n }\n\n private:\n // Container for a key-value pair\n struct Bucket {\n value_type value;\n bool occupied;\n };\n\n // Searches for a matching bucket with the given key\n Bucket* findMatchingBucket(const key_type& key) const {\n if (capacity_ == 0) {\n return nullptr;\n }\n\n size_type index = hash(key);\n const size_type start = index;\n Bucket* bucket = &data_[index];\n\n // Look for a matching bucket\n while (bucket->occupied) {\n if (bucket->value.first == key) {\n return bucket;\n }\n\n index = (index + 1) % capacity_;\n bucket = &data_[index];\n\n if (index == start) {\n return nullptr;\n }\n }\n\n return nullptr;\n }\n\n // Searches for an empty bucket with the given key\n Bucket* findEmptyBucket(const key_type& key) const {\n if (capacity_ == 0) {\n return nullptr;\n }\n\n size_type index = hash(key);\n const size_type start = index;\n Bucket* bucket = &data_[index];\n\n // Look for an empty bucket\n while (bucket->occupied) {\n index = (index + 1) % capacity_;\n bucket = &data_[index];\n\n if (index == start) {\n return nullptr;\n }\n }\n\n return bucket;\n }\n\n // Computes a hash of the given key that can be used as a table index\n size_type hash(const key_type& key) const { return Hash{}(key) % capacity_; }\n\n // Special value for returning a success\n const Expected kSuccess{};\n\n // Pointer to an array of entries\n Bucket* data_;\n // Maximum number of entries the container can hold\n size_type capacity_;\n // Number of entries stored\n size_type size_;\n};\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_COMMON_FIXED_MAP_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/fixed_string.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_COMMON_FIXED_STRING_HPP_\n#define NVIDIA_GXF_COMMON_FIXED_STRING_HPP_\n\n#include \n#include \n\n#include \"common/expected.hpp\"\n#include \"common/iterator.hpp\"\n#include \"common/type_utils.hpp\"\n\nnamespace nvidia {\n\n// Safety container that substitutes std::string and uses Expected for error handling.\n// Uses a fixed-size buffer allocated on the stack for storage.\ntemplate \nclass FixedString {\n public:\n // Use STL naming convention for compatibility with STL algorithms\n using value_type = char;\n using size_type = size_t;\n using const_iterator = ConstRandomAccessIterator;\n using const_reverse_iterator = ReverseIterator;\n\n // Hash support\n struct Hash {\n template \n size_t operator()(const FixedString& str) const {\n return std::_Hash_impl::hash(str.data(), str.size());\n }\n };\n\n // Custom error codes for container\n enum struct Error {\n kArgumentNull,\n kExceedingPreallocatedSize,\n };\n\n // Expected type which uses class specific errors\n template \n using Expected = Expected;\n\n // Constructors\n constexpr FixedString() { clear(); }\n template \n constexpr FixedString(const char (&str)[M]) { copy(str); }\n template \n constexpr FixedString(const FixedString& str) { copy(str); }\n\n // Assignment operators\n template \n constexpr FixedString& operator=(const char (&other)[M]) {\n copy(other);\n return *this;\n }\n template \n constexpr FixedString& operator=(const FixedString& other) {\n copy(other);\n return *this;\n }\n // ISO standards state the assignment operator for M = N cannot be a template\n constexpr FixedString& operator=(const FixedString& other) {\n copy(other);\n return *this;\n }\n\n constexpr const_iterator begin() const { return cbegin(); }\n constexpr const_iterator end() const { return cend(); }\n constexpr const_reverse_iterator rbegin() const { return crbegin(); }\n constexpr const_reverse_iterator rend() const { return crend(); }\n\n constexpr const_iterator cbegin() const { return const_iterator(*this, 0); }\n constexpr const_iterator cend() const { return const_iterator(*this, size_); }\n constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }\n constexpr const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }\n\n // Comparison operators\n template \n constexpr bool operator==(const char (&other)[M]) const { return compare(other) == 0; }\n template \n constexpr bool operator==(const FixedString& other) const { return compare(other) == 0; }\n template \n constexpr bool operator!=(const char (&other)[M]) const { return !(*this == other); }\n template \n constexpr bool operator!=(const FixedString& other) const { return !(*this == other); }\n template \n constexpr bool operator<(const char (&other)[M]) const { return compare(other) < 0; }\n template \n constexpr bool operator<(const FixedString& other) const { return compare(other) < 0; }\n template \n constexpr bool operator<=(const char (&other)[M]) const { return compare(other) <= 0; }\n template \n constexpr bool operator<=(const FixedString& other) const { return compare(other) <= 0; }\n template \n constexpr bool operator>(const char (&other)[M]) const { return !(*this <= other); }\n template \n constexpr bool operator>(const FixedString other) const { return !(*this <= other); }\n template \n constexpr bool operator>=(const char (&other)[M]) const { return !(*this < other); }\n template \n constexpr bool operator>=(const FixedString other) const { return !(*this < other); }\n\n // Returns the length of the string excluding the null terminator\n constexpr size_t size() const { return size_; }\n constexpr size_t length() const { return size_; }\n\n // Returns the number of characters the string can store excluding the null terminator\n constexpr size_t max_size() const { return kMaxSize; }\n\n // Returns the number of characters the string can store including the null terminator\n constexpr size_t capacity() const { return kCapacity; }\n\n // Returns true if the string is empty\n constexpr bool empty() const { return size_ == 0; }\n\n // Returns true if the string is full\n constexpr bool full() const { return size_ == kMaxSize; }\n\n // Returns a pointer to a null-terminated array of characters\n constexpr AddLvalueReference_t data() const { return data_; }\n constexpr AddLvalueReference_t c_str() const { return data_; }\n\n // Clears the string\n constexpr void clear() {\n size_ = 0;\n data_[size_] = '\\0';\n }\n\n // Appends a C-string to the end of the string\n constexpr Expected append(const char* str, size_t size) {\n if (str == nullptr) {\n return Unexpected{Error::kArgumentNull};\n }\n const size_t length = strnlen(str, size);\n if (size_ + length > kMaxSize) {\n return Unexpected{Error::kExceedingPreallocatedSize};\n }\n std::memcpy(&data_[size_], str, length);\n size_ += length;\n data_[size_] = '\\0';\n return kSuccess;\n }\n\n // Appends a character array to the end of the string\n template \n constexpr Expected append(const char (&str)[M]) { return append(str, M); }\n\n // Appends a fixed string to the end of the string\n template \n constexpr Expected append(const FixedString& str) {\n return append(str.data(), str.size());\n }\n\n // Appends a character to the end of the string\n constexpr Expected append(char c) { return append(&c, 1); }\n\n // Copies a C-string to the string\n constexpr Expected copy(const char* str, size_t size) {\n clear();\n return append(str, size);\n }\n\n // Copies a character array to the string\n template \n constexpr void copy(const char (&str)[M]) {\n static_assert(M <= kMaxSize, \"Exceeding container capacity\");\n copy(str, M);\n }\n\n // Copies a fixed string to the string\n template \n constexpr void copy(const FixedString& str) {\n static_assert(M <= kMaxSize, \"Exceeding container capacity\");\n copy(str.data(), str.size());\n }\n\n // Compares string to a character array\n template \n constexpr int compare(const char (&str)[M]) const {\n const size_t length = strnlen(str, M);\n const int result = std::strncmp(data_, str, std::min(size_, length));\n if (result != 0) {\n return result;\n }\n if (length > size_) {\n return -1;\n }\n if (length < size_) {\n return 1;\n }\n return 0;\n }\n\n // Compares string to a fixed string\n template \n constexpr int compare(const FixedString& str) const { return compare(str.data()); }\n\n private:\n // Storage capacity\n static constexpr size_t kCapacity = N + 1;\n // Maximum length of the string\n static constexpr size_t kMaxSize = N;\n\n // Special value for returning a success\n const Expected kSuccess{};\n\n // String length\n size_t size_;\n // Data buffer\n char data_[kCapacity];\n};\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_COMMON_FIXED_STRING_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/fixed_vector.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_COMMON_FIXED_VECTOR_HPP_\n#define NVIDIA_GXF_COMMON_FIXED_VECTOR_HPP_\n\n#include \n#include \n\n#include \"common/byte.hpp\"\n#include \"common/expected.hpp\"\n#include \"common/iterator.hpp\"\n#include \"common/memory_utils.hpp\"\n\nnamespace nvidia {\n\n// Data structure that provides similar functionality to std::vector but does not dynamically\n// reallocate memory and uses Expected type for error handling instead of exceptions.\n// This container is not thread-safe.\n//\n// This container supports allocating memory on the stack or on the heap. If the template argument\n// N is specified and greater than 0, a container with a capacity of N will be created on the stack.\n// The stack allocated container cannot be resized after it is initialized. The heap allocated\n// container must use the reserve function to allocate memory before use. It does not support\n// copy assignment or construction.\n\n// Base implementation\ntemplate \nclass FixedVectorBase {\n public:\n // Use STL naming convention for compatibility with STL algorithms\n using value_type = T;\n using size_type = size_t;\n using iterator = RandomAccessIterator;\n using reverse_iterator = ReverseIterator;\n using const_iterator = ConstRandomAccessIterator;\n using const_reverse_iterator = ReverseIterator;\n\n virtual ~FixedVectorBase() = default;\n\n // Custom error codes for vector\n enum struct Error {\n kOutOfMemory, // Memory allocation failed\n kArgumentOutOfRange, // Argument is out of valid range\n kContainerEmpty, // Container is empty\n kContainerFull, // Container is fixed and reached max capacity\n kInvalidIterator, // Iterator is invalid\n };\n\n // Expected type which uses class specific errors\n template \n using Expected = Expected;\n\n constexpr bool operator==(const FixedVectorBase& other) const {\n if (size_ != other.size_) {\n return false;\n }\n if (data_ == other.data_) {\n return true;\n }\n for (size_t i = 0; i < size_; i ++) {\n if (data_[i] != other.data_[i]) {\n return false;\n }\n }\n return true;\n }\n constexpr bool operator!=(const FixedVectorBase& other) const { return !(*this == other); }\n\n constexpr iterator begin() { return iterator(*this, 0); }\n constexpr iterator end() { return iterator(*this, size_); }\n constexpr reverse_iterator rbegin() { return reverse_iterator(end()); }\n constexpr reverse_iterator rend() { return reverse_iterator(begin()); }\n\n constexpr const_iterator begin() const { return cbegin(); }\n constexpr const_iterator end() const { return cend(); }\n constexpr const_reverse_iterator rbegin() const { return crbegin(); }\n constexpr const_reverse_iterator rend() const { return crend(); }\n\n constexpr const_iterator cbegin() const { return const_iterator(*this, 0); }\n constexpr const_iterator cend() const { return const_iterator(*this, size_); }\n constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }\n constexpr const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }\n\n constexpr Expected operator[](size_t index) { return at(index); }\n constexpr Expected operator[](size_t index) const { return at(index); }\n\n // Returns a pointer to data\n constexpr T* data() { return data_; }\n // Returns a read-only pointer to data\n constexpr const T* data() const { return data_; }\n // Returns the number of elements the vector can currently hold\n constexpr size_t capacity() const { return capacity_; }\n // Returns the number of elements in the vector\n constexpr size_t size() const { return size_; }\n // Returns true if the vector contains no elements\n constexpr bool empty() const { return size_ == 0; }\n // Returns true if the vector reached capacity\n constexpr bool full() const { return size_ == capacity_; }\n\n // Returns a reference to the element at the given index\n constexpr Expected at(size_t index) {\n if (index >= size_) {\n return Unexpected{Error::kArgumentOutOfRange};\n }\n return data_[index];\n }\n\n // Returns a read-only reference to the element at the given index\n constexpr Expected at(size_t index) const {\n if (index >= size_) {\n return Unexpected{Error::kArgumentOutOfRange};\n }\n return data_[index];\n }\n\n // Returns a reference to the first element\n constexpr Expected front() {\n if (empty()) {\n return Unexpected{Error::kContainerEmpty};\n }\n return data_[0];\n }\n\n // Returns a read-only reference to the first element\n constexpr Expected front() const {\n if (empty()) {\n return Unexpected{Error::kContainerEmpty};\n }\n return data_[0];\n }\n\n // Returns a reference to the last element\n constexpr Expected back() {\n if (empty()) {\n return Unexpected{Error::kContainerEmpty};\n }\n return data_[size_ - 1];\n }\n\n // Returns a read-only reference to the last element\n constexpr Expected back() const {\n if (empty()) {\n return Unexpected{Error::kContainerEmpty};\n }\n return data_[size_ - 1];\n }\n\n // Creates a new object with the provided arguments and adds it at the specified index\n template \n constexpr Expected emplace(size_t index, Args&&... args) {\n if (index > size_) {\n return Unexpected{Error::kArgumentOutOfRange};\n }\n if (full()) {\n return Unexpected{Error::kContainerFull};\n }\n if (index < size_) {\n ArrayMoveConstruct(BytePointer(&data_[index + 1]), &data_[index], size_ - index);\n }\n InplaceConstruct(BytePointer(&data_[index]), std::forward(args)...);\n size_++;\n return kSuccess;\n }\n\n // Creates a new object with the provided arguments and adds it to the end of the vector\n template \n constexpr Expected emplace_back(Args&&... args) {\n return emplace(size_, std::forward(args)...);\n }\n\n // Copies the object to the specified index\n constexpr Expected insert(size_t index, const T& obj) { return emplace(index, obj); }\n // Moves the object to the specified index\n constexpr Expected insert(size_t index, T&& obj) {\n return emplace(index, std::forward(obj));\n }\n\n // Insert elements from another fixed vector object to the specified index\n constexpr Expected insert(iterator index, const_iterator start, const_iterator end) {\n ssize_t count = static_cast(std::distance(start, end));\n size_t pos = static_cast(std::distance(begin(), index));\n if ((pos > size_) || (size_ + count > capacity_) || (count < 0)) {\n return Unexpected{Error::kArgumentOutOfRange};\n }\n\n auto maybe_value = *start;\n if (maybe_value) {\n const T* ptr = &(*maybe_value);\n if (pos < size_) {\n ArrayCopyConstruct(BytePointer(data_ + pos + count), &data_[pos], size_ - pos);\n }\n ArrayCopyConstruct(BytePointer(data_ + pos), ptr, count);\n size_ += count;\n } else {\n return Unexpected{Error::kInvalidIterator};\n }\n\n return kSuccess;\n }\n\n // Copies the object to the end of the vector\n constexpr Expected push_back(const T& obj) { return emplace_back(obj); }\n // Moves the object to the end of the vector\n constexpr Expected push_back(T&& obj) { return emplace_back(std::forward(obj)); }\n\n // Removes the object at the specified index and destroys it\n constexpr Expected erase(size_t index) {\n if (index >= size_) {\n return Unexpected{Error::kArgumentOutOfRange};\n }\n if (empty()) {\n return Unexpected{Error::kContainerEmpty};\n }\n Destruct(BytePointer(&data_[index]));\n size_--;\n if (index < size_) {\n ArrayMoveConstruct(BytePointer(&data_[index]), &data_[index + 1], size_ - index);\n }\n return kSuccess;\n }\n\n // Removes the object at the end of the vector and destroys it\n constexpr Expected pop_back() { return erase(size_ - 1); }\n\n // Removes all objects from the vector\n constexpr void clear() {\n while (size_ > 0) {\n Destruct(BytePointer(&data_[--size_]));\n }\n }\n\n // Resizes the vector by removing objects from the end if shrinking\n // or by adding default objects to the end if expanding\n constexpr Expected resize(size_t count) {\n if (count > capacity_) {\n return Unexpected{Error::kArgumentOutOfRange};\n }\n while (count > size_) {\n push_back(T());\n }\n while (count < size_) {\n pop_back();\n }\n return kSuccess;\n }\n\n // Resizes the vector by removing objects from the end if shrinking\n // or by adding copies of the given object to the end if expanding\n constexpr Expected resize(size_t count, const T& obj) {\n if (count > capacity_) {\n return Unexpected{Error::kArgumentOutOfRange};\n }\n while (count > size_) {\n push_back(obj);\n }\n while (count < size_) {\n pop_back();\n }\n return kSuccess;\n }\n\n protected:\n // Special value for returning a success\n const Expected kSuccess{};\n\n FixedVectorBase() : data_{nullptr}, capacity_{0}, size_{0} {};\n\n // Pointer to an array of objects\n T* data_;\n // Maximum number of objects the container can hold\n size_t capacity_;\n // Number of objects stored\n size_t size_;\n};\n\n// Special value used to instantiate a FixedVector with heap memory allocation\nconstexpr ssize_t kFixedVectorHeap = -1;\n\n// Vector with stack memory allocation\ntemplate \nclass FixedVector : public FixedVectorBase {\n public:\n static_assert(N >= 0, \"N must be non-negative\");\n\n constexpr FixedVector() {\n data_ = ValuePointer(pool_);\n capacity_ = N;\n }\n constexpr FixedVector(const FixedVector& other) { *this = other; }\n constexpr FixedVector(FixedVector&& other) { *this = std::move(other); }\n constexpr FixedVector& operator=(const FixedVector& other) {\n if (this != &other) {\n data_ = ValuePointer(pool_);\n capacity_ = N;\n ArrayCopyConstruct(BytePointer(data_), other.data_, other.size_);\n size_ = other.size_;\n }\n return *this;\n }\n constexpr FixedVector& operator=(FixedVector&& other) {\n if (this != &other) {\n data_ = ValuePointer(pool_);\n capacity_ = N;\n ArrayMoveConstruct(BytePointer(data_), other.data_, other.size_);\n std::swap(size_, other.size_);\n }\n return *this;\n }\n ~FixedVector() { FixedVectorBase::clear(); }\n\n private:\n using FixedVectorBase::data_;\n using FixedVectorBase::capacity_;\n using FixedVectorBase::size_;\n\n // Size of memory pool for stack allocation\n static constexpr size_t kPoolSize = N * sizeof(T);\n // Memory pool for storing objects on the stack\n byte pool_[kPoolSize];\n};\n\n// Vector with heap memory allocation\ntemplate \nclass FixedVector : public FixedVectorBase {\n public:\n template\n using Expected = typename FixedVectorBase::template Expected;\n\n constexpr FixedVector() = default;\n constexpr FixedVector(const FixedVector& other) = delete;\n constexpr FixedVector(FixedVector&& other) { *this = std::move(other); }\n constexpr FixedVector& operator=(const FixedVector& other) = delete;\n constexpr FixedVector& operator=(FixedVector&& other) {\n if (this != &other) {\n std::swap(data_, other.data_);\n std::swap(capacity_, other.capacity_);\n std::swap(size_, other.size_);\n }\n return *this;\n }\n ~FixedVector() {\n FixedVectorBase::clear();\n DeallocateArray(data_);\n }\n\n // Copies the contents of the given vector\n // Current contents are discarded\n // Fails if given vector is larger than current capacity\n constexpr Expected copy_from(const FixedVector& other) {\n if (other.size_ > capacity_) {\n return Unexpected{Error::kArgumentOutOfRange};\n }\n FixedVectorBase::clear();\n size_ = other.size_;\n ArrayCopyConstruct(BytePointer(data_), other.data_, size_);\n return kSuccess;\n }\n\n // Allocates memory to hold the specified number of elements\n constexpr Expected reserve(size_t capacity) {\n if (capacity > capacity_) {\n T* data = AllocateArray(capacity);\n if (!data) {\n return Unexpected{Error::kOutOfMemory};\n }\n ArrayMoveConstruct(BytePointer(data), data_, size_);\n DeallocateArray(data_);\n data_ = data;\n capacity_ = capacity;\n }\n return kSuccess;\n }\n\n // Shrinks memory allocation to fit current number of elements\n constexpr Expected shrink_to_fit() {\n if (size_ < capacity_) {\n T* data = AllocateArray(size_);\n if (!data) {\n return Unexpected(Error::kOutOfMemory);\n }\n ArrayMoveConstruct(BytePointer(data), data_, size_);\n DeallocateArray(data_);\n data_ = data;\n capacity_ = size_;\n }\n return kSuccess;\n }\n\n private:\n using Error = typename FixedVectorBase::Error;\n using FixedVectorBase::kSuccess;\n using FixedVectorBase::data_;\n using FixedVectorBase::capacity_;\n using FixedVectorBase::size_;\n};\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_COMMON_FIXED_VECTOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/iterator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_COMMON_ITERATOR_HPP_\n#define NVIDIA_GXF_COMMON_ITERATOR_HPP_\n\n#include \n\n#include \"common/expected.hpp\"\n#include \"common/type_utils.hpp\"\n\nnamespace nvidia {\n\nnamespace detail {\n\n/// Type traits to determine if a type has `data()`\ntemplate struct HasData : FalseType {};\ntemplate struct HasData().data())>> : TrueType {};\ntemplate constexpr bool HasData_v = HasData::value;\n\n/// Type traits to determine if a type has `size()`\ntemplate struct HasSize : FalseType {};\ntemplate struct HasSize().size())>> : TrueType {};\ntemplate constexpr bool HasSize_v = HasSize::value;\n\n} // namespace detail\n\n/// Random-access iterator for containers with elements in contiguous memory.\n/// A pointer to the container is stored so the iterator does not get invalidated if elements are\n/// added and/or removed from the container. Incrementing/decrementing operations will saturate\n/// if the iterator reaches the end/beginning of the container. Element access is wrapped in\n/// an `Expected` to prevent dereferencing invalid memory.\ntemplate \nclass RandomAccessIterator {\n static_assert(detail::HasData_v, \"TContainer must have data()\");\n static_assert(detail::HasSize_v, \"TContainer must have size()\");\n static_assert(IsIntegral_v().size())>,\n \"size() must return an integral type\");\n\n public:\n enum struct Error {\n kArgumentOutOfRange,\n kInvalidIterator,\n };\n\n template \n using Expected = Expected;\n\n // iterator traits\n using iterator_category = std::random_access_iterator_tag;\n using value_type = TValue;\n using difference_type = std::ptrdiff_t;\n using pointer = TValue*;\n using reference = TValue&;\n constexpr RandomAccessIterator() : container_{nullptr}, index_{-1} {}\n constexpr RandomAccessIterator(TContainer& container, size_t start)\n : container_{&container}, index_{0} {\n *this += start;\n }\n\n template ::value &&\n std::is_same::value, int>::type = 0>\n constexpr RandomAccessIterator(const RandomAccessIterator& other)\n : container_{other.container_}, index_{0} {\n *this += other.index_;\n }\n\n constexpr RandomAccessIterator(const RandomAccessIterator& other) = default;\n constexpr RandomAccessIterator(RandomAccessIterator&& other) = default;\n constexpr RandomAccessIterator& operator=(const RandomAccessIterator& other) = default;\n constexpr RandomAccessIterator& operator=(RandomAccessIterator&& other) = default;\n\n constexpr Expected operator*() const {\n return 0 <= index_ && index_ < static_cast(container_->size())\n ? Expected{container_->data()[index_]}\n : Unexpected{Error::kInvalidIterator};\n }\n constexpr Expected operator[](difference_type offset) const {\n if (container_ == nullptr) {\n return Unexpected{Error::kInvalidIterator};\n }\n difference_type index = index_ + offset;\n return 0 <= index && index < static_cast(container_->size())\n ? Expected{container_->data()[index]}\n : Unexpected{Error::kArgumentOutOfRange};\n }\n\n constexpr RandomAccessIterator& operator+=(difference_type offset) {\n if (container_ == nullptr) {\n return *this;\n }\n difference_type index = index_ + offset;\n if (index < 0) {\n index = 0;\n } else if (index > static_cast(container_->size())) {\n index = container_->size();\n }\n index_ = index;\n return *this;\n }\n constexpr RandomAccessIterator& operator++() {\n *this += 1;\n return *this;\n }\n constexpr RandomAccessIterator operator++(int) {\n RandomAccessIterator iter = *this;\n ++(*this);\n return iter;\n }\n constexpr RandomAccessIterator& operator-=(difference_type offset) {\n *this += -offset;\n return *this;\n }\n constexpr RandomAccessIterator& operator--() {\n *this -= 1;\n return *this;\n }\n constexpr RandomAccessIterator operator--(int) {\n RandomAccessIterator iter = *this;\n --(*this);\n return iter;\n }\n\n friend constexpr RandomAccessIterator operator+(RandomAccessIterator a, difference_type n) {\n a += n;\n return a;\n }\n friend constexpr RandomAccessIterator operator+(difference_type n, RandomAccessIterator a) {\n return a + n;\n }\n friend constexpr RandomAccessIterator operator-(RandomAccessIterator a, difference_type n) {\n a -= n;\n return a;\n }\n friend constexpr difference_type operator-(const RandomAccessIterator& a,\n const RandomAccessIterator& b) {\n return a.index_ - b.index_;\n }\n friend constexpr bool operator==(const RandomAccessIterator& a, const RandomAccessIterator& b) {\n return a.container_ == b.container_ && a.index_ == b.index_;\n }\n friend constexpr bool operator!=(const RandomAccessIterator& a, const RandomAccessIterator& b) {\n return !(a == b);\n }\n\n private:\n friend class RandomAccessIterator;\n /// Container pointer\n TContainer* container_;\n /// Iterator index\n difference_type index_;\n};\n\n/// Constant Random-access iterator\ntemplate \nusing ConstRandomAccessIterator = RandomAccessIterator;\n\n/// Reverse iterator\ntemplate \nclass ReverseIterator {\n public:\n using TValue = typename TIterator::value_type;\n using Error = typename TIterator::Error;\n\n template \n using Expected = Expected;\n\n // iterator traits\n using iterator_category = std::random_access_iterator_tag;\n using value_type = TValue;\n using difference_type = std::ptrdiff_t;\n using pointer = TValue*;\n using reference = TValue&;\n\n constexpr explicit ReverseIterator() : iter_{} {}\n constexpr explicit ReverseIterator(TIterator iter) : iter_{iter} {}\n\n constexpr ReverseIterator(const ReverseIterator& other) = default;\n constexpr ReverseIterator(ReverseIterator&& other) = default;\n constexpr ReverseIterator& operator=(const ReverseIterator& other) = default;\n constexpr ReverseIterator& operator=(ReverseIterator&& other) = default;\n\n constexpr TIterator base() const { return iter_; }\n\n constexpr Expected operator*() const { return *std::prev(iter_); }\n constexpr Expected operator[](difference_type offset) const {\n return std::prev(iter_)[-offset];\n }\n\n constexpr ReverseIterator& operator+=(difference_type offset) {\n iter_ -= offset;\n return *this;\n }\n constexpr ReverseIterator& operator++() {\n iter_ -= 1;\n return *this;\n }\n constexpr ReverseIterator operator++(int) {\n ReverseIterator iter = *this;\n ++(*this);\n return iter;\n }\n constexpr ReverseIterator& operator-=(difference_type offset) {\n iter_ += offset;\n return *this;\n }\n constexpr ReverseIterator& operator--() {\n iter_ += 1;\n return *this;\n }\n constexpr ReverseIterator operator--(int) {\n ReverseIterator iter = *this;\n --(*this);\n return iter;\n }\n\n friend constexpr ReverseIterator operator+(ReverseIterator a, difference_type n) {\n return ReverseIterator(a.iter_ - n);\n }\n friend constexpr ReverseIterator operator+(difference_type n, ReverseIterator a) {\n return ReverseIterator(a.iter_ - n);\n }\n friend constexpr ReverseIterator operator-(ReverseIterator a, difference_type n) {\n return ReverseIterator(a.iter_ + n);\n }\n friend constexpr difference_type operator-(const ReverseIterator& a, const ReverseIterator& b) {\n return b.iter_ - a.iter_;\n }\n friend constexpr bool operator==(const ReverseIterator& a, const ReverseIterator& b) {\n return a.iter_ == b.iter_;\n }\n friend constexpr bool operator!=(const ReverseIterator& a, const ReverseIterator& b) {\n return !(a == b);\n }\n\n private:\n /// Random-access iterator\n TIterator iter_;\n};\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_COMMON_ITERATOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/logger.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_LOGGER_HPP_\n#define NVIDIA_COMMON_LOGGER_HPP_\n\n#include \n#include \n#include \n\n#include \"gxf/logger/gxf_logger.hpp\"\n\n#define GXF_LOG_LEVEL_PANIC 0\n#define GXF_LOG_LEVEL_ERROR 1\n#define GXF_LOG_LEVEL_WARNING 2\n#define GXF_LOG_LEVEL_INFO 3\n#define GXF_LOG_LEVEL_DEBUG 4\n#define GXF_LOG_LEVEL_VERBOSE 5\n\n// clang-format off\n\n// Set the default active logging level to VERBOSE(5) if not defined\n#if !defined(GXF_LOG_ACTIVE_LEVEL)\n# define GXF_LOG_ACTIVE_LEVEL 5 // GXF_LOG_LEVEL_VERBOSE\n#endif\n\n// Define GXF_LOG_ACTIVE_LEVEL before including `common/logger.hpp` to control the logging level\n// at compile time. This allows you to skip logging at certain levels.\n//\n// Example:\n// #define GXF_LOG_ACTIVE_LEVEL 2\n// #include \"common/logger.hpp\"\n// ...\n//\n// With this setting, logging will occur only at the WARNING(2), ERROR(1), and PANIC(0) levels.\n//\n// You can define GXF_LOG_ACTIVE_LEVEL in your build system. For instance, in CMake, use:\n//\n// target_compile_definitions(my_target PRIVATE GXF_LOG_ACTIVE_LEVEL=2)\n//\n// This sets the active logging level to WARNING(2) for the target `my_target`.\n//\n// Alternatively, define GXF_LOG_ACTIVE_LEVEL at compile time by passing `-DGXF_LOG_ACTIVE_LEVEL=2`\n// directly to the compiler.\n//\n// In the Bazel build system, set this in your build configuration as follows:\n//\n// cc_binary(\n// name = \"my_binary\",\n// srcs = [\"my_binary.cc\"],\n// copts = [\"-DGXF_LOG_ACTIVE_LEVEL=2\"],\n// )\n//\n// This sets the active logging level to WARNING(2) for the target `my_binary`.\n//\n// Or, when using a Bazel build command:\n// bazel build --copt=-DGXF_LOG_ACTIVE_LEVEL=3 //path:to_your_target\n//\n// This sets the active logging level to INFO(3) for the target `//path:to_your_target`.\n\n// Logs a verbose message\n#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_VERBOSE\n# define GXF_LOG_VERBOSE(...) \\\n ::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::VERBOSE, __VA_ARGS__)\n#else\n# define GXF_LOG_VERBOSE(...) (void)0\n#endif\n\n// Logs a debug message\n#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_DEBUG\n# define GXF_LOG_DEBUG(...) \\\n ::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::DEBUG, __VA_ARGS__)\n#else\n# define GXF_LOG_DEBUG(...) (void)0\n#endif\n\n// Logs an informational message\n#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_INFO\n# define GXF_LOG_INFO(...) \\\n ::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::INFO, __VA_ARGS__)\n#else\n# define GXF_LOG_INFO(...) (void)0\n#endif\n\n// Logs a warning\n#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_WARNING\n# define GXF_LOG_WARNING(...) \\\n ::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::WARNING, __VA_ARGS__)\n#else\n# define GXF_LOG_WARNING(...) (void)0\n#endif\n\n// Logs an error\n#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_ERROR\n# define GXF_LOG_ERROR(...) \\\n ::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::ERROR, __VA_ARGS__)\n#else\n# define GXF_LOG_ERROR(...) (void)0\n#endif\n\n// Logs a panic\n#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_PANIC\n# define GXF_LOG_PANIC(...) \\\n ::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::PANIC, __VA_ARGS__)\n#else\n# define GXF_LOG_PANIC(...) (void)0\n#endif\n\n// clang-format on\n\nnamespace nvidia {\n\n// Function which is used for logging. It can be changed to intercept the logged messages.\n// Additional arguments can be supplied via LoggingFunctionArg.\nextern void (*LoggingFunction)(const char* file, int line, Severity severity,\n const char* log, void* arg);\nextern void* LoggingFunctionArg;\n\n// Default implementation of the logging function which prints to console\nvoid DefaultConsoleLogging(const char* file, int line, Severity severity,\n const char* log, void* arg);\n\n// Redirects the output for a given log severity.\nvoid Redirect(std::FILE* file, Severity severity = Severity::ALL);\n\n// Sets the log severity from the environment variable.\n// If the environment variable is not set or invalid, the severity is not changed.\n// Returns true if the environment variable is accessible and the severity was updated from it.\nbool SetSeverityFromEnv(const char* env_name = kGxfLogEnvName);\n\n// Returns the log severity from the environment variable.\n// If the environment variable is not set or invalid, returns Severity::COUNT.\n// If 'error_code' is not null, it will be set to 1 if the environment variable is set but invalid,\n// or to 0 otherwise.\nSeverity GetSeverityFromEnv(const char* env_name = kGxfLogEnvName, int* error_code = nullptr);\n\n// Sets global log severity thus effectively disabling all logging with lower severity\nvoid SetSeverity(Severity severity);\n\n// Returns global log severity\nSeverity GetSeverity();\n\n// Converts the message and argument into a string and pass it to LoggingFunction.\ntemplate\nvoid Log(const char* file, int line, Severity severity, const char* txt, ...) __attribute__((format(printf, 4, 5))); // NOLINT\n\ntemplate\nvoid Log(const char* file, int line, Severity severity, const char* txt, ...) {\n va_list args1;\n va_start(args1, txt);\n va_list args2;\n va_copy(args2, args1);\n std::vector buf(1 + std::vsnprintf(NULL, 0, txt, args1));\n va_end(args1);\n auto buf_data = buf.data();\n auto buf_size = buf.size();\n std::vsnprintf(buf_data, buf_size, txt, args2);\n va_end(args2);\n\n logger::GxfLogger& logger = logger::GlobalGxfLogger::instance();\n logger.log(file, line, nullptr, static_cast(severity), buf_data);\n}\n\n} // namespace nvidia\n\n#endif // NVIDIA_COMMON_LOGGER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/memory_utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_MEMORY_UTILS_HPP_\n#define NVIDIA_COMMON_MEMORY_UTILS_HPP_\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"common/byte.hpp\"\n\nnamespace nvidia {\n\n// Convert a raw byte pointer `src` to a concrete type T\ntemplate \nT* ValuePointer(byte* src) {\n return reinterpret_cast(src);\n}\n\n// Convert a const raw byte pointer `src` to a concrete type T\ntemplate \nconst T* ValuePointer(const byte* src) {\n return reinterpret_cast(src);\n}\n\n// Convert a type T pointer `src` to a raw byte pointer\ntemplate \nbyte* BytePointer(T* src) {\n return reinterpret_cast(src);\n}\n\n// Convert a const type T pointer `src` to a raw byte pointer\ntemplate \nconst byte* BytePointer(const T* src) {\n return reinterpret_cast(src);\n}\n\n// Call the destructor for type T on the object located at `src`.\ntemplate \nvoid Destruct(byte* src) {\n reinterpret_cast(src)->~T();\n}\n\n// Construct an object of type T with the provided arguments into the memory at `dst` with\n// placement new operator.\ntemplate \nT* InplaceConstruct(byte* dst, Args&&... args) {\n return new (dst) T{std::forward(args)...};\n}\n\n// Move construct an object of type T into the memory at `dst` with placement new operator.\ntemplate \nT* InplaceMoveConstruct(byte* dst, T&& other) {\n return new (dst) T{std::forward(other)};\n}\n\n// Copy construct an object of type T into the memory at `dst` with placement new operator.\ntemplate \nT* InplaceCopyConstruct(byte* dst, const T& other) {\n return new (dst) T{other};\n}\n\n// Move constructs an array of objects of type T into the memory at `dst`\n// Used if object is movable\ntemplate ::value>* = nullptr>\nvoid ArrayMoveConstruct(byte* dst, T* src, size_t count) {\n // Reverse move direction to handle overlapping memory segments\n const bool reverse = dst > BytePointer(src) && dst < BytePointer(src + count);\n for (size_t i = 0; i < count; i++) {\n const size_t index = reverse ? count - 1 - i : i;\n InplaceMoveConstruct(dst + sizeof(T) * index, std::move(src[index]));\n }\n}\n\n// Move constructs an array of objects of type T into the memory at `dst`\n// Used if object is not movable but trivially copyable\ntemplate ::value &&\n std::is_trivially_copyable::value>* = nullptr>\nvoid ArrayMoveConstruct(byte* dst, T* src, size_t count) {\n std::memmove(dst, src, sizeof(T) * count);\n}\n\n// Move constructs an array of objects of type T into the memory at `dst`\n// Used if object is not movable and not trivially copyable\ntemplate ::value &&\n !std::is_trivially_copyable::value>* = nullptr>\nvoid ArrayMoveConstruct(byte* dst, T* src, size_t count) {\n // Reverse move direction to handle overlapping memory segments\n const bool reverse = dst > BytePointer(src) && dst < BytePointer(src + count);\n for (size_t i = 0; i < count; i++) {\n const size_t index = reverse ? count - 1 - i : i;\n InplaceCopyConstruct(dst + sizeof(T) * index, src[index]);\n }\n}\n\n// Copy constructs an array of objects of type T into the memory at `dst`\n// Used if object is trivially copyable\ntemplate ::value>* = nullptr>\nvoid ArrayCopyConstruct(byte* dst, T* src, size_t count) {\n std::memmove(dst, src, sizeof(T) * count);\n}\n\n// Copy constructs an array of objects of type T into the memory at `dst`\n// Used if object is not trivially copyable\ntemplate ::value>* = nullptr>\nvoid ArrayCopyConstruct(byte* dst, T* src, size_t count) {\n // Reverse move direction to handle overlapping memory segments\n const bool reverse = dst > BytePointer(src) && dst < BytePointer(src + count);\n for (size_t i = 0; i < count; i++) {\n const size_t index = reverse ? count - 1 - i : i;\n InplaceCopyConstruct(dst + sizeof(T) * index, src[index]);\n }\n}\n\n// Allocates an array with `size` number of objects of type T\n// Does not call object constructor\ntemplate \nT* AllocateArray(size_t size) {\n return static_cast(::operator new(size * sizeof(T), std::nothrow));\n}\n\n// Deallocates the array `data` of objects of type T\n// Does not call object destructor\ntemplate \nvoid DeallocateArray(T* data) {\n ::operator delete(data);\n}\n\n// Construct an object of type T with the provided arguments and returns a unique pointer to it\n// Null pointer is returned on error\ntemplate \nstd::unique_ptr MakeUniqueNoThrow(Args&&... args) {\n return std::unique_ptr(new(std::nothrow) T{std::forward(args)...});\n}\n\n// Construct an object of type T with the provided arguments and returns a shared pointer to it\n// Null pointer is returned on error\ntemplate \nstd::shared_ptr MakeSharedNoThrow(Args&&... args) {\n return std::shared_ptr(new(std::nothrow) T{std::forward(args)...});\n}\n\n} // namespace nvidia\n\n#endif // NVIDIA_COMMON_MEMORY_UTILS_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/nvtx_helper.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_NVTX_HELPER_HPP_\n#define NVIDIA_COMMON_NVTX_HELPER_HPP_\n\n#include \n\n#include \"nvtx3/nvToolsExt.h\"\n\n// Helper functions to create named color events for NVTX profiling\n\ninline nvtxEventAttributes_t CreateGreenEvent(const std::string& message, uint32_t category) {\n nvtxEventAttributes_t eventAttrib = {0};\n eventAttrib.version = NVTX_VERSION;\n eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;\n eventAttrib.colorType = NVTX_COLOR_ARGB;\n eventAttrib.color = 0xFF76b900; // NVIDIA GREEN\n eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;\n eventAttrib.message.ascii = message.c_str();\n eventAttrib.category = category;\n\n return eventAttrib;\n}\n\ninline nvtxEventAttributes_t CreateRedEvent(const std::string& message, uint32_t category) {\n nvtxEventAttributes_t eventAttrib = {0};\n eventAttrib.version = NVTX_VERSION;\n eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;\n eventAttrib.colorType = NVTX_COLOR_ARGB;\n eventAttrib.color = 0xFFFe2712; // Red\n eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;\n eventAttrib.message.ascii = message.c_str();\n eventAttrib.category = category;\n\n return eventAttrib;\n}\n\n\ninline nvtxEventAttributes_t CreateBlackEvent(const std::string& message, uint32_t category) {\n nvtxEventAttributes_t eventAttrib = {0};\n eventAttrib.version = NVTX_VERSION;\n eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;\n eventAttrib.colorType = NVTX_COLOR_ARGB;\n eventAttrib.color = 0xFF010203; // Rich black\n eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;\n eventAttrib.message.ascii = message.c_str();\n eventAttrib.category = category;\n\n return eventAttrib;\n}\n\ninline nvtxEventAttributes_t CreateBlueEvent(const std::string& message, uint32_t category) {\n nvtxEventAttributes_t eventAttrib = {0};\n eventAttrib.version = NVTX_VERSION;\n eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;\n eventAttrib.colorType = NVTX_COLOR_ARGB;\n eventAttrib.color = 0xFF66a1fe; // Light Blue\n eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;\n eventAttrib.message.ascii = message.c_str();\n eventAttrib.category = category;\n\n return eventAttrib;\n}\n\n#endif // NVIDIA_COMMON_NVTX_HELPER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/singleton.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_SINGLETON_HPP_\n#define NVIDIA_COMMON_SINGLETON_HPP_\n\nnamespace gxf {\n\n// A singleton which supports creation at pre-execution time\n// Usage: For a class `MyType` with a member function `myMember` you can just write:\n// Singleton::Get().myMember();\n// This will automatically create a singleton, i.e. return the same instance each time you call Get.\n// The constructor of MyType will be called at pre-execution time, i.e. before entering main.\n// If you use multiple singletons they will all be created at pre-execution time, but you should\n// not rely on a particular instantiation order.\ntemplate \nstruct Singleton {\n public:\n Singleton& operator=(Singleton&) = delete;\n\n // Get the singleton\n static T& Get() {\n static T singleton;\n Use(dummy_);\n return singleton;\n }\n\n private:\n // Helpers to force pre-execution time\n static void Use(const T&) {}\n static T& dummy_;\n};\n\n// Force instantiation of the singleton at pre-execution time\ntemplate \nT& Singleton::dummy_ = Singleton::Get();\n\n} // namespace gxf\n\n#endif // NVIDIA_COMMON_SINGLETON_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/span.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_COMMON_SPAN_HPP_\n#define NVIDIA_GXF_COMMON_SPAN_HPP_\n\n#include \"common/byte.hpp\"\n#include \"common/expected.hpp\"\n#include \"common/iterator.hpp\"\n#include \"common/type_utils.hpp\"\n\nnamespace nvidia {\n\nnamespace detail {\n\n/// Type traits to enable comparing `Span` with `Span`\ntemplate using EnableIfComparable_t = EnableIf_t<\n IsSame_v, RemoveConst_t>\n>;\n\n/// Type traits to determine if type stores elements in contiguous memory\ntemplate using EnableIfContiguous_t = EnableIf_t, HasSize>>;\n\n} // namespace detail\n\n/// Container to hold a pointer and size for contiguous memory.\n/// `Span` can be passed between functions and components and ensures that the size of the array is\n/// always available and can be checked for safe memory access. `Span` only wraps existing memory.\ntemplate \nclass Span {\n public:\n using element_type = T;\n using value_type = RemoveCV_t;\n using size_type = size_t;\n using iterator = RandomAccessIterator;\n using reverse_iterator = ReverseIterator;\n\n /// Custom error codes for `Span`\n enum struct Error {\n kArgumentOutOfRange,\n kContainerEmpty,\n };\n\n /// `Expected` which uses `Span::Error`\n template \n using Expected = Expected;\n\n constexpr Span(T* data, size_t size) : data_{data}, size_{data != nullptr ? size : 0} {}\n constexpr Span() : Span(nullptr, 0) {}\n template \n constexpr Span(T (&array)[N]) : Span(array, N) {}\n /// Conversion from other types that have `data()` and `size()` functions\n template >\n constexpr Span(U& other) : Span(other.data(), other.size()) {}\n\n /// Implicit conversion from `Span` to `Span`\n operator Span() const { return Span(data_, size_); }\n\n ~Span() = default;\n\n constexpr Span(const Span& other) = default;\n constexpr Span(Span&& other) = default;\n constexpr Span& operator=(const Span&) = default;\n constexpr Span& operator=(Span&&) = default;\n\n constexpr iterator begin() const { return iterator(*this, 0); }\n constexpr iterator end() const { return iterator(*this, size_); }\n constexpr reverse_iterator rbegin() const { return reverse_iterator(end()); }\n constexpr reverse_iterator rend() const { return reverse_iterator(begin()); }\n\n constexpr Expected operator[](size_t index) const { return at(index); }\n\n /// Returns a pointer to the underlying data\n constexpr T* data() const { return data_; }\n /// Returns the number of elements in the `Span`\n constexpr size_t size() const { return size_; }\n /// Returns the size of the `Span` in bytes\n constexpr size_t size_bytes() const { return size_ * sizeof(T); }\n /// Returns true if the `Span` has no elements\n constexpr bool empty() const { return size_ == 0; }\n\n /// Returns a reference to the element at `index`\n constexpr Expected at(size_t index) const {\n return index < size_ ? Expected{data_[index]}\n : Unexpected{Error::kArgumentOutOfRange};\n }\n\n /// Returns a reference to the first element\n constexpr Expected front() const {\n return !empty() ? Expected{data_[0]}\n : Unexpected{Error::kContainerEmpty};\n }\n\n /// Returns a reference to the last element\n constexpr Expected back() const {\n return !empty() ? Expected{data_[size_ - 1]}\n : Unexpected{Error::kContainerEmpty};\n }\n\n /// Returns a `Span` consisting of `count` elements starting from `offset`\n constexpr Expected subspan(size_t offset, size_t count) const {\n return offset <= size_ && count <= size_ && offset + count <= size_\n ? Expected{Span(data_ + offset, count)}\n : Unexpected{Error::kArgumentOutOfRange};\n }\n\n /// Returns a `Span` starting from `offset`\n constexpr Expected subspan(size_t offset) const { return subspan(offset, size_ - offset); }\n /// Returns a `Span` consisting of the first `count` elements\n constexpr Expected first(size_t count) const { return subspan(0, count); }\n /// Returns a `Span` consisting of the last `count` elements\n constexpr Expected last(size_t count) const { return subspan(size_ - count, count); }\n\n private:\n /// Pointer to data\n T* data_;\n /// Size of data\n size_t size_;\n};\n\ntemplate >\nconstexpr bool operator==(const Span& a, const Span& b) {\n if (a.size() != b.size()) {\n return false;\n }\n if (a.data() == b.data()) {\n return true;\n }\n for (size_t i = 0; i < a.size(); i++) {\n if (a.data()[i] != b.data()[i]) {\n return false;\n }\n }\n return true;\n}\n\ntemplate >\nconstexpr bool operator!=(const Span& a, const Span& b) { return !(a == b); }\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_COMMON_SPAN_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/strong_type.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_COMMON_STRONG_TYPE_HPP_\n#define NVIDIA_GXF_COMMON_STRONG_TYPE_HPP_\n\n#include \n\n#include \"common/type_utils.hpp\"\n\nnamespace nvidia {\n\n/// The base type for a\n/// [strong type](https://www.fluentcpp.com/2016/12/08/strong-types-for-strong-interfaces).\n/// It is useful for making lightweight types which are distinct. Unlike type aliases\n/// (@c typedef or @c using), two @c StrongType types are not substitutable, even if the\n/// backing type is the same.\n///\n/// The primary use case for this type is numeric identifiers. For example, imagine a sensor\n/// system where the sensor is identified by a @c uint32_t. Beyond being a 32-bit integer, this\n/// value shares almost no properties with the C type. Arithmetic and bit shifts do not make a\n/// lot of sense for this value -- there is no meaning to the result of multiplication between\n/// two sensor IDs. Comparing a sensor ID to any non-sensor ID value is probably a bug. By\n/// wrapping ID values into a dedicated @c SensorId @c StrongType, this behavior is prevented.\n///\n/// @code\n/// // Create two types: Foo and Bar, both wrapping a uint64_t\n/// using Foo = StrongType;\n/// using Bar = StrongType;\n///\n/// void fooOnly(const Foo&);\n/// void barOnly(const Bar&);\n///\n/// int main() {\n/// // Values must be constructed explicitly\n/// auto foo = Foo(106);\n/// auto bar = Bar(314);\n///\n/// fooOnly(foo); // <- legal\n/// fooOnly(bar); // <- illegal: a Bar type is distinct from Foo\n/// fooOnly(foo.value()); // <- illegal: no implicit construction\n/// barOnly(foo); // <- illegal: foo is not a Bar\n/// }\n/// @endcode\ntemplate \nclass StrongType {\n public:\n /// The underlying type of this type.\n using value_type = TValue;\n\n /// Default-construct an instance. This overload is only enabled if\n /// @ref value_type is default-constructible.\n constexpr StrongType() = default;\n\n /// Construct an instance from @a value.\n ///\n /// @param value The value to convert from.\n template \n constexpr explicit\n StrongType(UValue&& value) noexcept(IsNothrowConstructible_v)\n : value_(std::forward(value)) {}\n\n constexpr explicit operator value_type() const& noexcept { return value_; }\n constexpr explicit operator value_type() & noexcept { return value_; }\n constexpr explicit operator value_type() && noexcept { return value_; }\n\n constexpr value_type const& value() const & noexcept { return value_; }\n constexpr value_type& value() & noexcept { return value_; }\n constexpr value_type&& value() && noexcept { return std::move(value_); }\n constexpr value_type const* operator->() const noexcept { return &value_; }\n constexpr value_type* operator->() noexcept { return &value_; }\n\n /// Comparison operatorions for the underlying type.\n friend constexpr bool operator==(const StrongType& lhs, const StrongType& rhs) {\n return lhs.value() == rhs.value();\n }\n friend constexpr bool operator!=(const StrongType& lhs, const StrongType& rhs) {\n return lhs.value() != rhs.value();\n }\n friend constexpr bool operator<=(const StrongType& lhs, const StrongType& rhs) {\n return lhs.value() <= rhs.value();\n }\n friend constexpr bool operator>=(const StrongType& lhs, const StrongType& rhs) {\n return lhs.value() >= rhs.value();\n }\n friend constexpr bool operator<(const StrongType& lhs, const StrongType& rhs) {\n return lhs.value() < rhs.value();\n }\n friend constexpr bool operator>(const StrongType& lhs, const StrongType& rhs) {\n return lhs.value() > rhs.value();\n }\n\n private:\n /// The underlying value of this type.\n value_type value_;\n};\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_COMMON_STRONG_TYPE_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/type_name.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_TYPE_NAME_HPP_\n#define NVIDIA_COMMON_TYPE_NAME_HPP_\n\n#include \n\n#if defined(__clang__)\ninline char* TypenameAsStringImpl(const char* begin, char* output, int32_t max_length) {\n // Return nullptr since this is not implemented\n return nullptr;\n}\n#elif defined(__GNUC__)\n#include \"type_name_gnuc.hpp\"\n#elif defined(_MSC_VER)\n// Not yet implemented\n#endif\n\nnamespace nvidia {\nnamespace helper {\n/**\n * Returns the pretty function name. It includes the complete function name along with the namespace\n * for template parameters.\n * Compiler using gcc-13 or later strips the namespace of the template parameter if\n * PRETTY_FUNCTION is called in the same namespace as that of the namespace of template parameter.\n * Compiler does not strip the namespace if the function that calls the PRETTY_FUNCTION macro is\n * called in a different namespace.\n *\n * @return the pretty function name as a const char*\n */\n template \n const char* PrettyFunctionName() {\n return __PRETTY_FUNCTION__;\n }\n\n/**\n * Returns the sizeof the pretty function name.\n */\n template \n constexpr int32_t PrettyFunctionSize() {\n return sizeof(__PRETTY_FUNCTION__);\n }\n} // namespace helper\n} // namespace nvidia\n\nnamespace nvidia {\n// Gives a string representation of the name of a C++ type.\n//\n// The function will compute the typename during the first invocation and store it in heap memory.\n// Computation of the typename is linear in the length of the typename and does not involve dynamic\n// memory allocations.\n//\n// For example:\n// namespace foo {\n// struct Bar {};\n// } // namespace\n// TyenameAsString(); // returns \"foo::Bar\"\n//\n// Note: Only \"simple\" class types in global namespace or a \"normal\" namespaces are guaranteed to\n// work. Templates, lambdas and anonymous namespaces are not guaranteed to work as expected.\ntemplate \nconst char* TypenameAsString() {\n // Ideally the typename string would be computed at compile time, however this does not seem to\n // be possible. Thus the typename string is computed the first time this function is evaluated\n // and cached for future function evaluations.\n const char* template_name = nvidia::helper::PrettyFunctionName();\n // Use upper bound to be safe.\n constexpr int32_t kMaxNameLength = nvidia::helper::PrettyFunctionSize();\n static char s_name[kMaxNameLength] = {0}; // Initialize with 0 to get a null-terminated string.\n static char* result = s_name;\n if (s_name[0] == 0 && result != nullptr) { // Check for first invocation of this function.\n result = TypenameAsStringImpl(template_name, s_name, kMaxNameLength);\n }\n return result;\n}\n\n} // namespace nvidia\n\n#endif // NVIDIA_COMMON_TYPE_NAME_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/type_name_gnuc.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_TYPE_NAME_GNUC_HPP_\n#define NVIDIA_COMMON_TYPE_NAME_GNUC_HPP_\n\n#include \n\nnamespace nvidia {\n\n// For the GNU compiler __PRETTY_FUNCTION__ is a null-terminated string with the following form:\n// const char* nvidia::TypenameAsString() [with T = nvidia::gxf::Component]\n// We would like to extract the type name as \"nvidia::gxf::Component\".\n// The result is stored in the given string 'output'. If the type name is longer than max_length\n// or another error occurs the function returns nullptr; otherwise 'output' is returned.\nchar* TypenameAsStringGnuC(const char* begin, char* output, int32_t max_length);\n\n// Compiler-specific implementation of the TypenameAsString function.\ninline char* TypenameAsStringImpl(const char* begin, char* output, int32_t max_length) {\n return TypenameAsStringGnuC(begin, output, max_length);\n}\n\n} // namespace nvidia\n\n#endif // NVIDIA_COMMON_TYPE_NAME_GNUC_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/type_utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_COMMON_TYPE_UTILS_HPP_\n#define NVIDIA_COMMON_TYPE_UTILS_HPP_\n\n#include \n\n// GXF definitions for common class definitions. These should behave identically\n// ISO standard definitions. They are defined locally to minimize dependencies of core GXF code\n// on any stl implementations.\nnamespace nvidia {\n\n// https://en.cppreference.com/w/cpp/types/void_t\ntemplate using void_t = void;\n\n// https://en.cppreference.com/w/cpp/types/type_identity\ntemplate struct TypeIdentity { using type = T; };\n\ntemplate using TypeIdentity_t = typename TypeIdentity::type;\n\n// https://en.cppreference.com/w/cpp/types/integral_constant\ntemplate struct IntegralConstant { static constexpr T value = v; };\ntemplate struct BoolConstant : IntegralConstant {};\n\nstruct TrueType : BoolConstant {};\nstruct FalseType : BoolConstant {};\n\n// https://en.cppreference.com/w/cpp/types/conditional\ntemplate struct Conditional : TypeIdentity {};\ntemplate struct Conditional : TypeIdentity {};\n\ntemplate using Conditional_t = typename Conditional::type;\n\n// https://en.cppreference.com/w/cpp/types/conjunction\ntemplate \nstruct Conjunction : TrueType {};\n\ntemplate \nstruct Conjunction : Conditional, B>::type {};\n\ntemplate constexpr bool Conjunction_v = Conjunction::value;\n\n// https://en.cppreference.com/w/cpp/types/disjunction\ntemplate \nstruct Disjunction : FalseType {};\n\ntemplate \nstruct Disjunction : Conditional>::type {};\n\ntemplate constexpr bool Disjunction_v = Disjunction::value;\n\n// https://en.cppreference.com/w/cpp/types/negation\ntemplate struct Negation : BoolConstant(B::value)> {};\n\ntemplate constexpr bool Negation_v = Negation::value;\n\n// https://en.cppreference.com/w/cpp/types/remove_reference\ntemplate struct RemoveReference : TypeIdentity {};\ntemplate struct RemoveReference : TypeIdentity {};\ntemplate struct RemoveReference : TypeIdentity {};\n\ntemplate using RemoveReference_t = typename RemoveReference::type;\n\n// https://en.cppreference.com/w/cpp/types/remove_cv\ntemplate struct RemoveCV : TypeIdentity {};\ntemplate struct RemoveCV : TypeIdentity {};\ntemplate struct RemoveCV : TypeIdentity {};\ntemplate struct RemoveCV : TypeIdentity {};\n\ntemplate using RemoveCV_t = typename RemoveCV::type;\n\ntemplate struct RemoveConst : TypeIdentity {};\ntemplate struct RemoveConst : TypeIdentity {};\n\ntemplate using RemoveConst_t = typename RemoveConst::type;\n\ntemplate struct RemoveVolatile : TypeIdentity {};\ntemplate struct RemoveVolatile : TypeIdentity {};\n\ntemplate using RemoveVolatile_t = typename RemoveVolatile::type;\n\n// https://en.cppreference.com/w/cpp/types/remove_cvref\ntemplate struct RemoveCVRef : RemoveCV::type>{};\n\ntemplate using RemoveCVRef_t = typename RemoveCVRef::type;\n\n// https://en.cppreference.com/w/cpp/types/add_reference\ntemplate \nstruct AddLvalueReference {\n private:\n template static constexpr TypeIdentity Test(void*);\n template static constexpr TypeIdentity Test(...);\n public:\n using type = typename decltype(Test(nullptr))::type;\n};\n\ntemplate \nstruct AddRvalueReference {\n private:\n template static constexpr TypeIdentity Test(void*);\n template static constexpr TypeIdentity Test(...);\n public:\n using type = typename decltype(Test(nullptr))::type;\n};\n\ntemplate using AddLvalueReference_t = typename AddLvalueReference::type;\ntemplate using AddRvalueReference_t = typename AddRvalueReference::type;\n\n// https://en.cppreference.com/w/cpp/utility/declval\ntemplate \nAddRvalueReference_t Declval() noexcept {\n static_assert(Conditional_t::value,\n \"Declval() cannot be used in an evaluated context.\");\n}\n\n// https://en.cppreference.com/w/cpp/types/decay\ntemplate \nstruct Decay {\n private:\n template static constexpr auto Id(U u) noexcept { return u; }\n template static constexpr decltype(Id(Declval())) Test(void*);\n template static constexpr void Test(...) {}\n public:\n using type = decltype(Test(nullptr));\n};\n\ntemplate using Decay_t = typename Decay::type;\n\n// https://en.cppreference.com/w/cpp/types/enable_if\ntemplate struct EnableIf {};\ntemplate struct EnableIf : TypeIdentity {};\n\ntemplate using EnableIf_t = typename EnableIf::type;\n\n// https://en.cppreference.com/w/cpp/types/is_same\ntemplate struct IsSame : FalseType {};\ntemplate struct IsSame : TrueType {};\n\ntemplate constexpr bool IsSame_v = IsSame::value;\n\n// https://en.cppreference.com/w/cpp/types/is_void\ntemplate struct IsVoid : IsSame::type> {};\n\ntemplate constexpr bool IsVoid_v = IsVoid::value;\n\n// // https://en.cppreference.com/w/cpp/types/is_const\ntemplate struct IsConst : FalseType {};\ntemplate struct IsConst : TrueType {};\n\ntemplate constexpr bool IsConst_v = IsConst::value;\n\n// https://en.cppreference.com/w/cpp/types/is_reference\ntemplate struct IsReference : FalseType {};\ntemplate struct IsReference : TrueType {};\ntemplate struct IsReference : TrueType {};\n\ntemplate constexpr bool IsReference_v = IsReference::value;\n\n// https://en.cppreference.com/w/cpp/types/is_constructible\ntemplate \nstruct IsConstructible {\n private:\n template(Declval()))>\n static constexpr bool TestCast(void*) { return true; }\n\n template\n static constexpr bool TestCast(...) { return false; }\n\n template \n struct Test : FalseType {};\n\n template \n struct Test<1, U, void> : BoolConstant(nullptr)> {};\n\n template \n struct Test()...))>> : TrueType {};\n\n public:\n static constexpr bool value = Test::value;\n};\n\ntemplate \nconstexpr bool IsConstructible_v = IsConstructible::value;\n\n// https://en.cppreference.com/w/cpp/types/is_default_constructible\ntemplate \nusing IsDefaultConstructible = IsConstructible;\n\ntemplate \nconstexpr bool IsDefaultConstructible_v = IsDefaultConstructible::value;\n\n// https://en.cppreference.com/w/cpp/types/is_nothrow_constructible\ntemplate \nstruct IsNothrowConstructible {\n private:\n template(Declval()))>\n static constexpr bool TestCast(void*) { return Result; }\n\n template\n static constexpr bool TestCast(...) { return false; }\n\n template\n struct Test : FalseType {};\n\n template\n struct Test<0, U, void_t> : BoolConstant {};\n\n template\n struct Test<1, U, void> : BoolConstant(nullptr)> {};\n\n template\n struct Test()...))>>\n : BoolConstant()...))> {};\n\n public:\n static constexpr bool value = Test::value;\n};\n\ntemplate \nconstexpr bool IsNothrowConstructible_v = IsNothrowConstructible::value;\n\n// https://en.cppreference.com/w/cpp/types/is_nothrow_default_constructible\ntemplate \nusing IsNothrowDefaultConstructible = IsNothrowConstructible;\n\ntemplate \nconstexpr bool IsNothrowDefaultConstructible_v = IsNothrowDefaultConstructible::value;\n\n// https://en.cppreference.com/w/cpp/types/is_convertible\ntemplate \nstruct IsConvertible {\n private:\n template ()(Declval()))>\n static constexpr bool Test(void*) { return true; }\n template \n static constexpr bool Test(...) { return false; }\n public:\n static constexpr bool value = (IsVoid_v && IsVoid_v) || Test(nullptr);\n};\n\ntemplate \nconstexpr bool IsConvertible_v = IsConvertible::value;\n\n// https://en.cppreference.com/w/cpp/types/is_convertible\ntemplate \nstruct IsNothrowConvertible {\n private:\n template \n static constexpr T DecayFunc(T) noexcept;\n template (Declval()))>\n static constexpr bool Test(void*) { return Result; }\n template \n static constexpr bool Test(...) { return false; }\n public:\n static constexpr bool value = (IsVoid_v && IsVoid_v) || Test(nullptr);\n};\n\ntemplate \nconstexpr bool IsNothrowConvertible_v = IsNothrowConvertible::value;\n\n// https://en.cppreference.com/w/cpp/types/is_assignable\ntemplate \nstruct IsAssignable : FalseType {};\n\ntemplate \nstruct IsAssignable() = Declval())>> : TrueType{};\n\ntemplate constexpr bool IsAssignable_v = IsAssignable::value;\n\n// https://en.cppreference.com/w/cpp/types/is_integral\ntemplate \nstruct IsIntegral : BoolConstant<\n IsSame_v::type> ||\n IsSame_v::type> ||\n IsSame_v::type> ||\n IsSame_v::type> ||\n IsSame_v::type> ||\n IsSame_v::type> ||\n IsSame_v::type> ||\n IsSame_v::type> ||\n IsSame_v::type>> {};\n\ntemplate constexpr bool IsIntegral_v = IsIntegral::value;\n\n// https://en.cppreference.com/w/cpp/types/is_floating_point\ntemplate \nstruct IsFloatingPoint : BoolConstant<\n IsSame_v::type> ||\n IsSame_v::type> ||\n IsSame_v::type>> {};\n\ntemplate constexpr bool IsFloatingPoint_v = IsFloatingPoint::value;\n\n// https://en.cppreference.com/w/cpp/types/is_arithmetic\ntemplate \nstruct IsArithmetic : BoolConstant || IsFloatingPoint_v> {};\n\ntemplate constexpr bool IsArithmetic_v = IsArithmetic::value;\n\n// https://en.cppreference.com/w/cpp/types/is_signed\ntemplate > struct IsSigned : BoolConstant<(T(-1) < T(0))> {};\ntemplate struct IsSigned : FalseType {};\ntemplate constexpr bool IsSigned_v = IsSigned::value;\n\n// https://en.cppreference.com/w/cpp/types/is_unsigned\ntemplate > struct IsUnsigned : BoolConstant<(T(0) < T(-1))> {};\ntemplate struct IsUnsigned : FalseType {};\ntemplate constexpr bool IsUnsigned_v = IsUnsigned::value;\n\n// https://en.cppreference.com/w/cpp/types/make_signed\ntemplate >> struct MakeSigned : TypeIdentity {};\ntemplate <> struct MakeSigned : TypeIdentity {};\ntemplate <> struct MakeSigned : TypeIdentity {};\ntemplate <> struct MakeSigned : TypeIdentity {};\ntemplate <> struct MakeSigned : TypeIdentity {};\ntemplate using MakeSigned_t = typename MakeSigned::type;\n\n// https://en.cppreference.com/w/cpp/types/make_unsigned\ntemplate >> struct MakeUnsigned : TypeIdentity {};\ntemplate <> struct MakeUnsigned : TypeIdentity {};\ntemplate <> struct MakeUnsigned : TypeIdentity {};\ntemplate <> struct MakeUnsigned : TypeIdentity {};\ntemplate <> struct MakeUnsigned : TypeIdentity {};\ntemplate using MakeUnsigned_t = typename MakeUnsigned::type;\n\n} // namespace nvidia\n\n#endif // NVIDIA_COMMON_TYPE_UTILS_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/unique_index_map.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_COMMON_UNIQUE_INDEX_MAP_HPP_\n#define NVIDIA_GXF_COMMON_UNIQUE_INDEX_MAP_HPP_\n\n#include \"common/expected.hpp\"\n\nnamespace nvidia {\n\n// Provides a basic fixed capacity container for tracking objects and assigning a unique id to every\n// object inserted. It provides constant time insert/delete/access for all elements with the\n// generated uid. This container guarantees that uids are never reused, and will return an\n// Unexpected Error if it runs out of capacity.\ntemplate \nclass UniqueIndexMap {\n private:\n // number of bits to use for holding the version number\n static constexpr uint64_t kVersionSize = 32;\n // number of bits to use for holding the index into the underlying container\n static constexpr uint64_t kIndexSize = 32;\n // bitmask for Version number\n static constexpr uint64_t kVersionMask = ((1ULL << kVersionSize) - 1ULL) << kIndexSize;\n // bitmask for Index number\n static constexpr uint64_t kIndexMask = (1ULL << kIndexSize) - 1ULL;\n\n static_assert(kIndexSize + kVersionSize == 64, \"Invalid UID bit length\");\n static_assert((kVersionMask ^ kIndexMask) == 0xFFFFFFFFFFFFFFFF,\n \"bitmasks must cover full size of uint64_t\");\n\n public:\n // Custom Error codes for construction and access of UniqueIndexMap map.\n enum struct Error {\n kArgumentInvalid, // Invalid construction/initialization parameter\n kOutOfMemory, // Could not allocate memory during initialization\n kContainerFull, // UniqueIndexMap is full\n kNotFound // UID does not exits in UniqueIndexMap\n };\n\n // Expected type for UniqueIndexMap which uses class specific Error type.\n template \n using Expected = Expected;\n\n UniqueIndexMap() : uids_{nullptr}, data_{nullptr}, capacity_{0}, size_{0}, next_{0} {}\n UniqueIndexMap(const UniqueIndexMap&) = delete;\n UniqueIndexMap(UniqueIndexMap&& other)\n : uids_{other.uids_},\n data_{other.data_},\n capacity_{other.capacity_},\n size_{other.size_},\n next_{other.next_} {\n other.reset_values();\n }\n\n UniqueIndexMap& operator=(const UniqueIndexMap& other) = delete;\n UniqueIndexMap& operator=(UniqueIndexMap&& other) {\n deinitialize();\n uids_ = other.uids_;\n data_ = other.data_;\n capacity_ = other.capacity_;\n size_ = other.size_;\n next_ = other.next_;\n\n other.reset_values();\n return *this;\n }\n\n ~UniqueIndexMap() {\n deinitialize();\n }\n\n // Deallocates the memory allocated in initialize\n void deinitialize() {\n for (uint64_t i = 0; i < capacity_; ++i) {\n if (GetIndex(uids_[i]) == i) {\n data_[i].~T();\n }\n }\n\n delete[] uids_;\n ::operator delete(data_);\n reset_values();\n }\n\n // Allocate memory up to the provided capacity and initialize values for implicit free list.\n // Returns Unexpected if max_capacity is too large.\n Expected initialize(uint64_t max_capacity) {\n if (max_capacity > (1ULL << kIndexSize)) {\n return Unexpected{Error::kArgumentInvalid};\n }\n\n capacity_ = max_capacity;\n\n uids_ = new (std::nothrow) uint64_t[max_capacity];\n data_ = static_cast(::operator new(max_capacity * sizeof(T), std::nothrow));\n\n if (uids_ == nullptr || data_ == nullptr) {\n return Unexpected{Error::kOutOfMemory};\n }\n\n for (uint64_t i = 0; i < max_capacity; ++i) {\n uids_[i] = i + 1;\n }\n return {};\n }\n\n // Check if there exists an object with the provided UID. Returns true if the uid exists in the\n // allocated range and if the version numbers match.\n bool valid(uint64_t uid) const {\n const uint64_t idx = GetIndex(uid);\n return (idx < capacity_) && (uids_[idx] == uid);\n }\n\n // Insert a new object into the container and return the generated UID via move constructor.\n // Return Unexpected if the object cannot be inserted.\n Expected insert(T&& object) { return emplace(static_cast(object)); }\n\n // Insert a new object into the container and return the generated UID via copy constructor.\n // Return Unexpected if the object cannot be inserted.\n Expected insert(const T& object) { return emplace(object); }\n\n // Construct a new object with the provided arguments directly in the container, and return the\n // generated UID via copy. Return Unexpected if the object cannot be inserted.\n template \n Expected emplace(Args&&... args) {\n if (size_ == capacity_) {\n return Unexpected{Error::kOutOfMemory};\n }\n\n if (GetVersion(next_) == (1ULL << kVersionSize) - 1ULL) {\n return Unexpected{Error::kContainerFull};\n }\n\n const uint64_t idx = GetIndex(next_);\n const uint64_t temp = next_;\n next_ = uids_[idx];\n uids_[idx] = temp + (1ULL << kIndexSize);\n new (&data_[idx]) T{static_cast(args)...};\n ++size_;\n return uids_[idx];\n }\n\n // Erase the object tracked by UID. Return Unexpected if UID is not valid.\n Expected erase(uint64_t uid) {\n if (!valid(uid)) {\n return Unexpected{Error::kNotFound};\n }\n\n uint64_t idx = GetIndex(uid);\n uids_[idx] = next_;\n next_ = uid;\n --size_;\n data_[idx].~T();\n\n return {};\n }\n\n // Get a pointer to the object tracked by UID. Returns an error if UID is not valid.\n Expected try_get(uint64_t uid) {\n if (!valid(uid)) {\n return Unexpected{Error::kNotFound};\n }\n return &data_[GetIndex(uid)];\n }\n\n // Get a pointer to the object tracked by UID. Returns an error if UID is not valid.\n Expected try_get(uint64_t uid) const {\n if (!valid(uid)) {\n return Unexpected{Error::kNotFound};\n }\n return &data_[GetIndex(uid)];\n }\n\n // Performs a linear search and returns the UID of the object.\n // Returns an error if object is not found\n Expected find(const T& object) const {\n for (size_t i = 0; i < capacity_; i++) {\n if (valid(uids_[i]) && data_[i] == object) {\n return uids_[i];\n }\n }\n return Unexpected{Error::kNotFound};\n }\n\n // Maximum capacity of the unique index map.\n inline uint64_t capacity() const { return capacity_; }\n\n // Current number of elements in the container.\n inline uint64_t size() const { return size_; }\n\n private:\n static uint64_t GetVersion(uint64_t uid) { return uid >> kIndexSize; }\n static uint64_t GetIndex(uint64_t uid) { return uid & kIndexMask; }\n\n // Resets all pointers and storage parameters to zero, without calling delete, primarily to be\n // used with move operators.\n void reset_values() {\n uids_ = nullptr;\n data_ = nullptr;\n capacity_ = 0;\n size_ = 0;\n next_ = 0;\n }\n\n uint64_t* uids_; // ids with implicit list of free elements\n T* data_; // objects storage\n uint64_t capacity_; // maximum number of concurrent objects\n uint64_t size_; // current number of objects\n uint64_t next_; // next \"free\" element in the container\n};\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_COMMON_UNIQUE_INDEX_MAP_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/common/yaml_parser.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_COMMON_YAML_PARSER_HPP_\n#define NVIDIA_GXF_COMMON_YAML_PARSER_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"common/logger.hpp\"\n#include \"yaml-cpp/yaml.h\"\n\n\ninline static bool is_space(unsigned char c) {\n return c == ' ';\n}\n\n/**\n * Custom YAML parser for std::complex types\n *\n * Handles parsing of strings containing a complex floating point value.\n *\n * Examples of valid strings are:\n * \"1.0 + 2.5j\"\n * \"-1.0 - 3i\"\n * \"1+3.3j\"\n *\n * There may be 0 or 1 space between a + or - sign and the digits.\n * Either \"i\" or \"j\" must appear immediately after the second number.\n */\ntemplate \nstruct YAML::convert> {\n static Node encode(const std::complex& data) {\n std::stringstream ss;\n ss << data.real();\n if (data.imag() >= 0) {\n ss << '+';\n }\n ss << data.imag() << 'j';\n Node node = YAML::Load(ss.str());\n return node;\n }\n\n static bool decode(const Node& node, std::complex& data) {\n if (!node.IsScalar()) {\n GXF_LOG_ERROR(\"complex decode: expected a scalar\");\n return false;\n }\n std::string value = node.as();\n\n std::regex complex_reg(\"\\\\s*([+-]?\\\\s?\\\\d*\\\\.?\\\\d+)\\\\s?([+-]{1}\\\\s?\\\\d*\\\\.?\\\\d+)[ij]{1}\\\\s*$\");\n std::smatch m;\n if (std::regex_search(value, m, complex_reg)) {\n if (m.size() != 3) {\n GXF_LOG_ERROR(\"unexpected match size: [%ld], matched: [%s]\", m.size(), m.str(0).c_str());\n }\n // extract the real and imaginary components of the number\n std::string real_str = m.str(1);\n std::string imag_str = m.str(2);\n\n // remove any white space around + or - (necessary for std::stod to work)\n real_str.erase(std::remove_if(real_str.begin(), real_str.end(), is_space), real_str.end());\n imag_str.erase(std::remove_if(imag_str.begin(), imag_str.end(), is_space), imag_str.end());\n\n // format real and imaginary strings as floating point\n double real = std::stod(real_str);\n double imag = std::stod(imag_str);\n data = std::complex(real, imag);\n } else {\n GXF_LOG_ERROR(\"failed to match expected regex for complex\");\n return false;\n }\n return true;\n }\n};\n\n\n// operator overload for std::complex\ntemplate \nYAML::Emitter& operator<<(YAML::Emitter& out, const std::complex& c) {\n std::stringstream ss;\n ss << c.real();\n if (c.imag() >= 0) ss << '+';\n ss << c.imag() << 'j';\n out << ss.str();\n return out;\n}\n\n#endif // NVIDIA_GXF_COMMON_YAML_PARSER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/dlpack/dlpack.h", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2017-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef DLPACK_DLPACK_H_\n#define DLPACK_DLPACK_H_\n\n/**\n * \\brief Compatibility with C++\n */\n#ifdef __cplusplus\n#define DLPACK_EXTERN_C extern \"C\"\n#else\n#define DLPACK_EXTERN_C\n#endif\n\n/*! \\brief The current version of dlpack */\n#define DLPACK_VERSION 80\n\n/*! \\brief The current ABI version of dlpack */\n#define DLPACK_ABI_VERSION 1\n\n/*! \\brief DLPACK_DLL prefix for windows */\n#ifdef _WIN32\n#ifdef DLPACK_EXPORTS\n#define DLPACK_DLL __declspec(dllexport)\n#else\n#define DLPACK_DLL __declspec(dllimport)\n#endif\n#else\n#define DLPACK_DLL\n#endif\n\n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n/*!\n * \\brief The device type in DLDevice.\n */\n#ifdef __cplusplus\ntypedef enum : int32_t {\n#else\ntypedef enum {\n#endif\n /*! \\brief CPU device */\n kDLCPU = 1,\n /*! \\brief CUDA GPU device */\n kDLCUDA = 2,\n /*!\n * \\brief Pinned CUDA CPU memory by cudaMallocHost\n */\n kDLCUDAHost = 3,\n /*! \\brief OpenCL devices. */\n kDLOpenCL = 4,\n /*! \\brief Vulkan buffer for next generation graphics. */\n kDLVulkan = 7,\n /*! \\brief Metal for Apple GPU. */\n kDLMetal = 8,\n /*! \\brief Verilog simulator buffer */\n kDLVPI = 9,\n /*! \\brief ROCm GPUs for AMD GPUs */\n kDLROCM = 10,\n /*!\n * \\brief Pinned ROCm CPU memory allocated by hipMallocHost\n */\n kDLROCMHost = 11,\n /*!\n * \\brief Reserved extension device type,\n * used for quickly test extension device\n * The semantics can differ depending on the implementation.\n */\n kDLExtDev = 12,\n /*!\n * \\brief CUDA managed/unified memory allocated by cudaMallocManaged\n */\n kDLCUDAManaged = 13,\n /*!\n * \\brief Unified shared memory allocated on a oneAPI non-partititioned\n * device. Call to oneAPI runtime is required to determine the device\n * type, the USM allocation type and the sycl context it is bound to.\n *\n */\n kDLOneAPI = 14,\n /*! \\brief GPU support for next generation WebGPU standard. */\n kDLWebGPU = 15,\n /*! \\brief Qualcomm Hexagon DSP */\n kDLHexagon = 16,\n} DLDeviceType;\n\n/*!\n * \\brief A Device for Tensor and operator.\n */\ntypedef struct {\n /*! \\brief The device type used in the device. */\n DLDeviceType device_type;\n /*!\n * \\brief The device index.\n * For vanilla CPU memory, pinned memory, or managed memory, this is set to 0.\n */\n int32_t device_id;\n} DLDevice;\n\n/*!\n * \\brief The type code options DLDataType.\n */\ntypedef enum {\n /*! \\brief signed integer */\n kDLInt = 0U,\n /*! \\brief unsigned integer */\n kDLUInt = 1U,\n /*! \\brief IEEE floating point */\n kDLFloat = 2U,\n /*!\n * \\brief Opaque handle type, reserved for testing purposes.\n * Frameworks need to agree on the handle data type for the exchange to be well-defined.\n */\n kDLOpaqueHandle = 3U,\n /*! \\brief bfloat16 */\n kDLBfloat = 4U,\n /*!\n * \\brief complex number\n * (C/C++/Python layout: compact struct per complex number)\n */\n kDLComplex = 5U,\n /*! \\brief boolean */\n kDLBool = 6U,\n} DLDataTypeCode;\n\n/*!\n * \\brief The data type the tensor can hold. The data type is assumed to follow the\n * native endian-ness. An explicit error message should be raised when attempting to\n * export an array with non-native endianness\n *\n * Examples\n * - float: type_code = 2, bits = 32, lanes = 1\n * - float4(vectorized 4 float): type_code = 2, bits = 32, lanes = 4\n * - int8: type_code = 0, bits = 8, lanes = 1\n * - std::complex: type_code = 5, bits = 64, lanes = 1\n * - bool: type_code = 6, bits = 8, lanes = 1 (as per common array library convention, the underlying storage size of bool is 8 bits)\n */\ntypedef struct {\n /*!\n * \\brief Type code of base types.\n * We keep it uint8_t instead of DLDataTypeCode for minimal memory\n * footprint, but the value should be one of DLDataTypeCode enum values.\n * */\n uint8_t code;\n /*!\n * \\brief Number of bits, common choices are 8, 16, 32.\n */\n uint8_t bits;\n /*! \\brief Number of lanes in the type, used for vector types. */\n uint16_t lanes;\n} DLDataType;\n\n/*!\n * \\brief Plain C Tensor object, does not manage memory.\n */\ntypedef struct {\n /*!\n * \\brief The data pointer points to the allocated data. This will be CUDA\n * device pointer or cl_mem handle in OpenCL. It may be opaque on some device\n * types. This pointer is always aligned to 256 bytes as in CUDA. The\n * `byte_offset` field should be used to point to the beginning of the data.\n *\n * Note that as of Nov 2021, multiply libraries (CuPy, PyTorch, TensorFlow,\n * TVM, perhaps others) do not adhere to this 256 byte aligment requirement\n * on CPU/CUDA/ROCm, and always use `byte_offset=0`. This must be fixed\n * (after which this note will be updated); at the moment it is recommended\n * to not rely on the data pointer being correctly aligned.\n *\n * For given DLTensor, the size of memory required to store the contents of\n * data is calculated as follows:\n *\n * \\code{.c}\n * static inline size_t GetDataSize(const DLTensor* t) {\n * size_t size = 1;\n * for (tvm_index_t i = 0; i < t->ndim; ++i) {\n * size *= t->shape[i];\n * }\n * size *= (t->dtype.bits * t->dtype.lanes + 7) / 8;\n * return size;\n * }\n * \\endcode\n */\n void* data;\n /*! \\brief The device of the tensor */\n DLDevice device;\n /*! \\brief Number of dimensions */\n int32_t ndim;\n /*! \\brief The data type of the pointer*/\n DLDataType dtype;\n /*! \\brief The shape of the tensor */\n int64_t* shape;\n /*!\n * \\brief strides of the tensor (in number of elements, not bytes)\n * can be NULL, indicating tensor is compact and row-majored.\n */\n int64_t* strides;\n /*! \\brief The offset in bytes to the beginning pointer to data */\n uint64_t byte_offset;\n} DLTensor;\n\n/*!\n * \\brief C Tensor object, manage memory of DLTensor. This data structure is\n * intended to facilitate the borrowing of DLTensor by another framework. It is\n * not meant to transfer the tensor. When the borrowing framework doesn't need\n * the tensor, it should call the deleter to notify the host that the resource\n * is no longer needed.\n */\ntypedef struct DLManagedTensor {\n /*! \\brief DLTensor which is being memory managed */\n DLTensor dl_tensor;\n /*! \\brief the context of the original host framework of DLManagedTensor in\n * which DLManagedTensor is used in the framework. It can also be NULL.\n */\n void * manager_ctx;\n /*! \\brief Destructor signature void (*)(void*) - this should be called\n * to destruct manager_ctx which holds the DLManagedTensor. It can be NULL\n * if there is no way for the caller to provide a reasonable destructor.\n * The destructors deletes the argument self as well.\n */\n void (*deleter)(struct DLManagedTensor * self);\n} DLManagedTensor;\n#ifdef __cplusplus\n} // DLPACK_EXTERN_C\n#endif\n#endif // DLPACK_DLPACK_H_" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/application.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_APPLICATION_HPP_\n#define NVIDIA_GXF_APPLICATION_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"gxf/app/arg.hpp\"\n#include \"gxf/app/config_parser.hpp\"\n#include \"gxf/app/driver.hpp\"\n#include \"gxf/app/extension_manager.hpp\"\n#include \"gxf/app/segment.hpp\"\n#include \"gxf/app/worker.hpp\"\n#include \"gxf/core/expected_macro.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\n\nnamespace gxf {\n\ntemplate \nstd::shared_ptr create_app(Args&&... args) {\n auto app = std::make_shared(std::forward(args)...);\n return app;\n}\n\n/**\n * @brief Enum representing the application mode of execution.\n * An application can either have segments or entities in its\n * compose() api.\n */\nenum class ExecutionMode : int8_t {\n kUnset = 0,\n kSingleSegment,\n kMultiSegment,\n kDistributed,\n};\n\n/**\n * @brief Scaffolding layer to create applications imperatively. Users implement a virtual\n * compose() api where individual building blocks of an application is constructed, configured\n * and connected with each other.\n *\n */\nclass Application : public Segment {\n private:\n friend class Worker;\n friend class Driver;\n public:\n Application();\n\n ~Application();\n\n Application(const Application&) = delete;\n\n Application& operator=(const Application&) = delete;\n\n Application(Application&&) = delete;\n\n Application& operator=(Application&&) = delete;\n\n virtual void compose() {}\n\n /**\n * @brief Set segment config file\n *\n * @param file_path Absolute path to the yaml config file for segments\n * distributed execution\n * @return Expected Success or error code\n */\n Expected setConfig(const std::string& file_path);\n\n /**\n * @brief Set segment config file\n *\n * @param argc CLI argument count\n * @param argv CLI argument array, the second is config file path for segments\n * distributed execution\n * @return Expected Success or error code\n */\n Expected setConfig(int argc, char** argv);\n\n /**\n * @brief Creates a segment in plan with its own context. The graph for the segment\n * will be composed() after creation\n *\n * @tparam SegmentT Type of segment\n * @param name Name of the segment\n * @return std::shared_ptr Shared pointer of the segment\n */\n template >>>\n std::shared_ptr createSegment(const char* name) {\n if (segments_plan_.find(name) != segments_plan_.end()) {\n GXF_LOG_ERROR(\"ProxySegment with name [%s] already exists. \"\n \"Segment names have to be unique\", name);\n return nullptr;\n }\n std::shared_ptr element = std::make_shared();\n element->setName(name);\n segments_plan_.emplace(name, element);\n return element;\n }\n\n /**\n * @brief API to load extensions at runtime\n *\n * @param manifest path to manifest file with list of extensions\n * @return Expected Success or error code\n */\n Expected loadExtensionManifest(const char* manifest);\n\n /**\n * @brief Adds a UCX connection between two entities with many : many tx and rx\n * Ucx Transmitter and Ucx Receiver components are added to the source and target entities in\n * both of the segments\n * @param source Segment with the entity transmitting the message\n * @param target Segment with the entity receiving entity. A message available term is added\n * along with the Ucx Receiver\n * @param port_maps Segment port map with entity and queue name to be used for connection.\n * @return Expected Success if connection was added successfully, error code on failure\n */\n Expected connect(SegmentPtr source, SegmentPtr target,\n std::vector port_maps);\n\n /**\n * @brief Sets the severity level of the logs (corresponding to GXF_LOG_* logging macros)\n * for a specific segment\n *\n *\n * @param name Name of the segment\n * @param severity a valid severity level as defined in `gxf_severity_t`. Logs corresponding to\n * any level <= severity will be logged.\n * @return gxf_result_t On success the function returns GXF_SUCCESS.\n */\n gxf_result_t setSegmentSeverity(const char* name, gxf_severity_t severity);\n\n /**\n * @brief A blocking api to run the graph. If the application contains multiple segments,\n * each segment is launched asynchronously and this thread is blocked until each one of\n * the segments have finished execution. If the graph contains multiple entities,\n * then this thread is blocked until the graph execution is complete.\n * @return Expected Success or error code\n */\n Expected run();\n\n /**\n * @brief A non blocking api call to run an application. If the application contains multiple\n * segments, each segment is launched asynchronously.\n * @return Expected Success or error code\n */\n Expected runAsync();\n\n /**\n * @brief A non blocking api to stop all running running segments or entities.\n *\n * @return Expected Success or error code\n */\n Expected interrupt();\n\n /**\n * @brief A blocking API to waits until the graph execution has completed\n *\n * @return Expected Success or error code\n */\n Expected wait();\n\n /**\n * @brief In-place add a GraphWorker Component into Application's root context,\n * in which case Application's context should only hold and run GraphWorker or GraphDriver\n */\n template \n Expected setWorker(const std::string& name, Args... args) {\n if (worker_ != nullptr) {\n GXF_LOG_ERROR(\"Worker already created with name: %s\", worker_->name().c_str());\n return Unexpected{GXF_FAILURE};\n }\n worker_ = std::make_shared(this, name);\n\n std::vector arg_list;\n if constexpr (sizeof...(args) > 0) { arg_list = parseArgsOfType(args...); }\n // 1. parse worker its own port\n int32_t port = -1;\n Expected arg_port = findArg(arg_list, kPort, GXF_PARAMETER_TYPE_INT32);\n if (!arg_port) {\n GXF_LOG_ERROR(\"Failed to find arg: %s when set GraphWorker[%s]\", kPort, name.c_str());\n return Unexpected{arg_port.error()};\n }\n port = arg_port.value().as();\n // 2. parse driver_ip\n std::string driver_ip;\n Expected arg_driver_ip = findArg(arg_list, kDriverIp, GXF_PARAMETER_TYPE_STRING);\n if (!arg_driver_ip) {\n GXF_LOG_ERROR(\"Arg 'driver_ip' is wrong when set GraphWorker[%s]\", name.c_str());\n return Unexpected{arg_driver_ip.error()};\n }\n driver_ip = arg_driver_ip.value().as();\n // 3. parse driver_port\n int32_t driver_port = -1;\n Expected arg_driver_port = findArg(arg_list, kDriverPort, GXF_PARAMETER_TYPE_INT32);\n if (!arg_driver_port) {\n GXF_LOG_ERROR(\"Arg 'driver_port' is wrong when set GraphWorker[%s]\", name.c_str());\n return Unexpected{arg_driver_port.error()};\n }\n driver_port = arg_driver_port.value().as();\n\n std::unordered_set segment_names;\n for (const auto& arg : arg_list) {\n auto it = segments_.find(arg.key());\n if (it != segments_.end()) {\n GXF_LOG_DEBUG(\"Add Segment[name: %s] to GraphWorker[name: %s]\",\n it->first.c_str(), name.c_str());\n segment_names.emplace(it->first);\n }\n }\n if (!segment_names.empty()) {\n GXF_LOG_ERROR(\"No segments selected in setWorker() arg list\");\n return Unexpected{GXF_ARGUMENT_INVALID};\n }\n RETURN_IF_ERROR(worker_->setPort(port));\n RETURN_IF_ERROR(worker_->setDriverIp(driver_ip));\n RETURN_IF_ERROR(worker_->setDriverPort(driver_port));\n RETURN_IF_ERROR(worker_->setSegments(segment_names));\n return Success;\n }\n\n /**\n * @brief In-place add a GraphDriver Component into Application's root context,\n * in which case Application's context should only hold and run GraphWorker or GraphDriver\n */\n template \n Expected setDriver(const std::string& name, Args... args) {\n if (driver_ != nullptr) {\n GXF_LOG_ERROR(\"Driver already created with name: %s\", driver_->name().c_str());\n return Unexpected{GXF_FAILURE};\n }\n driver_ = std::make_shared(this, name);\n\n std::vector arg_list;\n if constexpr (sizeof...(args) > 0) { arg_list = parseArgsOfType(args...); }\n // parse driver its own port\n int32_t port = -1;\n Expected arg_port = findArg(arg_list, kPort, GXF_PARAMETER_TYPE_INT32);\n if (!arg_port) {\n GXF_LOG_ERROR(\"Arg 'port' is wrong when set GraphDriver[%s]\", name.c_str());\n return Unexpected{arg_port.error()};\n }\n port = arg_port.value().as();\n\n RETURN_IF_ERROR(driver_->setPort(port));\n return Success;\n }\n\n using Segment::connect;\n\n private:\n Expected commitCompose();\n Expected commitSegment(SegmentPtr segment, const char* name);\n Expected commitConnect(SegmentPtr source, SegmentPtr target,\n std::vector port_maps);\n Expected checkConfiguration();\n Expected activate();\n Expected deactivate();\n Expected finalize();\n Expected setupCrashHandler();\n\n std::map> segments_;\n std::map> segments_plan_;\n std::unordered_set segment_connections_;\n std::unordered_set segment_connections_plan_;\n std::unordered_set enabled_segments_;\n std::string name_;\n ExecutionMode mode_{ExecutionMode::kUnset};\n ExtensionManager extension_manager_;\n uint64_t next_ucx_port_ = 13337U; // will be set to DEFAULT_UCX_PORT by constructor\n WorkerPtr worker_;\n DriverPtr driver_;\n std::unique_ptr config_parser_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_APPLICATION_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/arg.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_GRAPH_ARG_HPP_\n#define NVIDIA_GXF_GRAPH_ARG_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"yaml-cpp/yaml.h\"\n\n#include \"common/type_name.hpp\"\n#include \"common/type_utils.hpp\"\n#include \"gxf/core/parameter_parser.hpp\"\n#include \"gxf/core/parameter_parser_std.hpp\"\n#include \"gxf/core/parameter_registrar.hpp\"\n#include \"gxf/core/parameter_wrapper.hpp\"\n\nnamespace nvidia {\n\nnamespace gxf {\n\nclass ProxyComponent;\n\n/**\n * @brief Struct to hold type info of an Arg\n *\n */\ntypedef struct ArgInfo {\n gxf_parameter_type_t type;\n std::string type_name;\n int32_t rank = 0;\n std::array::kMaxRank> shape = {0};\n} ArgInfo;\n\n/**\n * @brief ArgOverride for scalar parameter type\n *\n * @tparam T A valid argument type\n */\ntemplate \nstruct ArgOverride {\n static Expected apply(ArgInfo& info) {\n info.type = ParameterTypeTrait::type;\n info.type_name.assign(ParameterTypeTrait::type_name);\n info.rank = 0;\n if (info.type == GXF_PARAMETER_TYPE_CUSTOM) { return Unexpected{GXF_ARGUMENT_INVALID}; }\n return Success;\n }\n\n static Expected wrap(const T& value) { return YAML::Node(value); }\n};\n\n/**\n * @brief Specialized ArgOverride for args of type handle\n *\n * @tparam T A valid argument type\n */\ntemplate \nstruct ArgOverride> {\n static Expected apply(ArgInfo& info) {\n info.type = GXF_PARAMETER_TYPE_HANDLE;\n info.type_name.assign(TypenameAsString());\n info.rank = 0;\n return Success;\n }\n\n static Expected wrap(const Handle& value) {\n std::string c_name = value.name();\n const char* entity_name;\n gxf_uid_t eid = kNullUid;\n auto result = GxfComponentEntity(value.context(), value.cid(), &eid);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Unable to find the entity for %s\", c_name.c_str());\n return Unexpected{result};\n }\n result = GxfEntityGetName(value.context(), eid, &entity_name);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Unable to get the entity name\");\n return Unexpected{result};\n }\n\n std::string full_name = std::string(entity_name) + \"/\" + c_name;\n return YAML::Node(full_name);\n }\n};\n\n/**\n * @brief Specialized ArgOverride for args of type std::vector\n *\n * @tparam T A valid argument type\n */\ntemplate \nstruct ArgOverride> {\n static Expected apply(ArgInfo& info) {\n // Get the element info\n ArgInfo element_info;\n const auto result = ArgOverride::apply(element_info);\n if (!result) { return ForwardError(result); }\n\n info.type = element_info.type;\n info.type_name = element_info.type_name;\n\n // Fetch the shape of and update it to the current ArgInfo\n for (int32_t i = 0; i < element_info.rank; ++i) { info.shape[i] = element_info.shape[i]; }\n\n // A vector increases the rank by 1 and adds shape [-1] to .\n info.shape[element_info.rank] = -1;\n info.rank = element_info.rank + 1;\n\n return Success;\n }\n\n static Expected wrap(const std::vector& value) {\n YAML::Node node(YAML::NodeType::Sequence);\n for (const auto& val : value) {\n auto maybe = ArgOverride::wrap(val);\n if (!maybe) { return Unexpected{maybe.error()}; }\n node.push_back(maybe.value());\n }\n return node;\n }\n};\n\n/**\n * @brief Specialized ArgOverride for parameters of type std::array\n *\n * @tparam T A valid argument type\n * @tparam N length of the array\n */\ntemplate \nstruct ArgOverride> {\n static Expected apply(ArgInfo& info) {\n // Get the element info\n ArgInfo element_info;\n const auto result = ArgOverride::apply(element_info);\n if (!result) { return ForwardError(result); }\n\n info.type = element_info.type;\n info.type_name = element_info.type_name;\n\n // Fetch the shape of and update it to the current ArgInfo\n for (int32_t i = 0; i < element_info.rank; ++i) { info.shape[i] = element_info.shape[i]; }\n\n // An array increases the rank by 1 and adds shape [N] to .\n info.shape[element_info.rank] = N;\n info.rank = element_info.rank + 1;\n\n return Success;\n }\n\n static Expected wrap(const std::array& value) {\n YAML::Node node(YAML::NodeType::Sequence);\n for (const auto& val : value) {\n auto maybe = ArgOverride::wrap(val);\n if (!maybe) { return Unexpected{maybe.error()}; }\n node.push_back(maybe.value());\n }\n return node;\n }\n};\n\n/**\n * @brief Specialized ArgOverride for parameters of type ProxyComponent\n *\n */\ntemplate <>\nstruct ArgOverride {\n static Expected apply(ArgInfo& info) {\n info.type = GXF_PARAMETER_TYPE_HANDLE;\n info.rank = 0;\n return Success;\n }\n\n static Expected wrap(const ProxyComponent& value) { return YAML::Node(); }\n};\n\n/**\n * @brief Argument interface to enable configuring parameters in GXF Components from\n * the application layer. All parameter types from gxf_parameter_type_t enum is supported.\n *\n */\nclass Arg {\n public:\n ~Arg() = default;\n\n // Constructors\n explicit Arg(const std::string& key) : key_(key) {}\n\n template \n Arg(const std::string& key, const T& value) {\n key_ = key;\n auto result = ArgOverride::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg [%s] of type [%s] with error [%s]\", key.c_str(),\n TypenameAsString(), GxfResultStr(result.error()));\n return;\n }\n set_value(value);\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key.c_str(), info_.type_name.c_str());\n }\n\n template \n Arg(const std::string& key, const Handle& value) {\n key_ = key;\n auto result = ArgOverride>::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg type %s \", key.c_str());\n return;\n }\n set_value>(value);\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key.c_str(), info_.type_name.c_str());\n if (!value.is_null()) {\n handle_cid_ = value->cid();\n // handle_tid_ = value->tid();\n GxfComponentTypeId(value.context(), info_.type_name.c_str(), &handle_tid_);\n }\n }\n\n // Special case for string literals typed arguments\n Arg(const std::string& key, const char* value) {\n key_ = key;\n auto result = ArgOverride::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg [%s] of type [%s] with error [%s]\", key.c_str(),\n TypenameAsString(), GxfResultStr(result.error()));\n return;\n }\n set_value(value);\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key.c_str(), info_.type_name.c_str());\n }\n\n Arg(const std::string& key, const ProxyComponent& value) {\n key_ = key;\n info_.type = GXF_PARAMETER_TYPE_HANDLE;\n // info_.type_name = value.type_name();\n handle_cid_ = kUnspecifiedUid;\n info_.rank = 0;\n set_value(value);\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key.c_str(), info_.type_name.c_str());\n }\n\n template ::value>>\n Arg(const std::string& key, T&& value) {\n using DeducedT = std::remove_reference_t>;\n key_ = key;\n auto result = ArgOverride::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg type %s \", key.c_str());\n return;\n }\n set_value(std::forward(value));\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key.c_str(), info_.type_name.c_str());\n }\n\n template ::value>>\n Arg(const std::string& key, Handle&& value) {\n using DeducedT = std::remove_reference_t>>;\n key_ = key;\n auto result = ArgOverride::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg type %s \", key.c_str());\n return;\n }\n if (!value.is_null()) {\n handle_cid_ = value->cid();\n // handle_tid_ = value->tid();\n GxfComponentTypeId(value.context(), info_.type_name.c_str(), &handle_tid_);\n }\n set_value>(std::forward>(value));\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key.c_str(), info_.type_name.c_str());\n }\n\n Arg(const std::string& key, ProxyComponent&& value) {\n key_ = key;\n info_.type = GXF_PARAMETER_TYPE_HANDLE;\n // info_.type_name = value.type_name();\n handle_cid_ = kUnspecifiedUid;\n info_.rank = 0;\n set_value(std::forward(value));\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key.c_str(), info_.type_name.c_str());\n }\n\n template >>>\n Arg& operator=(const T& value) {\n auto result = ArgOverride::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg type %s \", key_.c_str());\n return *this;\n }\n set_value(value);\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key_.c_str(), info_.type_name.c_str());\n return *this;\n }\n\n template >>>\n Arg& operator=(const Handle& value) {\n auto result = ArgOverride>::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg type %s \", key_.c_str());\n return *this;\n }\n if (!value.is_null()) {\n handle_cid_ = value->cid();\n // handle_tid_ = value->tid();\n GxfComponentTypeId(value.context(), info_.type_name.c_str(), &handle_tid_);\n }\n set_value>(value);\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key_.c_str(), info_.type_name.c_str());\n return *this;\n }\n\n Arg& operator=(ProxyComponent& value) {\n info_.type = GXF_PARAMETER_TYPE_HANDLE;\n // info_.type_name = value.type_name();\n handle_cid_ = kUnspecifiedUid;\n info_.rank = 0;\n set_value(value);\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key_.c_str(), info_.type_name.c_str());\n return *this;\n }\n\n template > &&\n !std::is_lvalue_reference::value>>\n Arg&& operator=(T&& value) {\n using DeducedT = std::remove_reference_t>;\n auto result = ArgOverride::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg type %s \", key_.c_str());\n return std::move(*this);\n }\n set_value(std::forward(value));\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key_.c_str(), info_.type_name.c_str());\n return std::move(*this);\n }\n\n template >> &&\n !std::is_lvalue_reference>::value>>\n Arg&& operator=(Handle&& value) {\n using DeducedT = std::remove_reference_t>>;\n auto result = ArgOverride::apply(info_);\n if (!result) {\n GXF_LOG_ERROR(\"Invalid Arg type %s \", key_.c_str());\n return std::move(*this);\n }\n if (!value.is_null()) {\n handle_cid_ = value->cid();\n // handle_tid_ = value->tid();\n GxfComponentTypeId(value.context(), info_.type_name.c_str(), &handle_tid_);\n }\n set_value>(std::forward>(value));\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key_.c_str(), info_.type_name.c_str());\n return std::move(*this);\n }\n\n Arg&& operator=(ProxyComponent&& value) {\n info_.type = GXF_PARAMETER_TYPE_HANDLE;\n // info_.type_name = value.type_name();\n handle_cid_ = kUnspecifiedUid;\n info_.rank = 0;\n set_value(value);\n GXF_LOG_VERBOSE(\"Arg: [%s], Type : [%s] created\", key_.c_str(), info_.type_name.c_str());\n return std::move(*this);\n }\n\n template >>\n T as() const {\n const T* value = std::any_cast(&value_);\n if (value == nullptr) {\n GXF_LOG_ERROR(\"Arg [%s] cannot be read as [%s]\", key_.c_str(), TypenameAsString());\n return T();\n }\n return *value;\n }\n\n const gxf_uid_t handle_uid() const { return handle_cid_; }\n\n const gxf_tid_t handle_tid() const { return handle_tid_; }\n\n const char* key() const { return key_.c_str(); }\n\n const std::string arg_type_name() const { return info_.type_name; }\n\n const ArgInfo arg_info() const { return info_; }\n\n const YAML::Node yaml_node() const { return yaml_node_; }\n\n const int32_t rank() const { return info_.rank; }\n\n const std::array::kMaxRank> shape() const { return info_.shape; }\n\n const gxf_parameter_type_t parameter_type() const { return info_.type; }\n\n bool has_value() const { return value_.has_value(); }\n\n std::any value() const { return value_; }\n\n private:\n std::any value_;\n std::string key_;\n ArgInfo info_;\n gxf_uid_t handle_cid_ = kNullUid;\n gxf_tid_t handle_tid_ = GxfTidNull();\n YAML::Node yaml_node_{};\n\n template \n void set_value(const T& value) {\n value_ = value;\n auto maybe_yaml = ArgOverride::wrap(value);\n if (!maybe_yaml) {\n GXF_LOG_ERROR(\"Arg [%s] failed to parse as a YAML node with error [%s]\", key_.c_str(),\n GxfResultStr(maybe_yaml.error()));\n } else {\n yaml_node_ = maybe_yaml.value();\n }\n }\n\n template \n void set_value(T&& value) {\n auto maybe_yaml = ArgOverride::wrap(value);\n if (!maybe_yaml) {\n GXF_LOG_ERROR(\"Arg [%s] failed to parse as a YAML node with error [%s]\", key_.c_str(),\n GxfResultStr(maybe_yaml.error()));\n } else {\n yaml_node_ = maybe_yaml.value();\n }\n value_ = std::move(value);\n }\n};\n\n} // namespace gxf\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_ARG_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/arg_parse.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_GRAPH_ARG_PARSE_HPP_\n#define NVIDIA_GXF_GRAPH_ARG_PARSE_HPP_\n\n#include \n#include \n\n#include \"gxf/app/arg.hpp\"\n#include \"gxf/app/proxy_component.hpp\"\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief Function returns a list of elements filtered from an input parameter pack of\n * arguments\n *\n * @tparam T Type of parameter to be filtered from the parameter pack\n * @return std::vector\n */\ntemplate \nstd::vector parseArgsOfType(const First& first, const Rest&... rest) {\n std::vector arg_list;\n if constexpr (std::is_same_v) { arg_list.push_back(first); }\n if constexpr (sizeof...(rest) > 0) {\n auto rest_list = parseArgsOfType(rest...);\n arg_list.insert(arg_list.end(), rest_list.begin(), rest_list.end());\n }\n return arg_list;\n}\n\n\n// Returns a list of proxyComponent args from a list of args\n// The proxy component args are removed from the input arg list\nstd::vector filterProxyComponents(std::vector& args);\n\n// Sets a parameter value for a component using the info stored in Arg type\nExpected applyArg(Handle component, const Arg& arg);\n\n// Returns an arg from a list of args\nExpected findArg(const std::vector& args, const std::string& key,\n const gxf_parameter_type_t type);\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_ARG_PARSE_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/config_parser.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_GRAPH_CONFIG_PARSER_HPP_\n#define NVIDIA_GXF_GRAPH_CONFIG_PARSER_HPP_\n\n#include \n#include \n#include \n\n#include \"gxf/core/expected.hpp\"\n#include \"yaml-cpp/yaml.h\"\n\nnamespace YAML { class Node; }\n\nnamespace nvidia {\nnamespace gxf {\n\n// identifiers\nstatic constexpr const char* kSegmentConfig = \"segment_config\";\nstatic constexpr const char* kMemberType = \"member\";\nstatic constexpr const char* kMemberParam = \"parameters\";\nstatic constexpr const char* kEnabledSegments = \"enabled_segments\";\nstatic constexpr const char* kWorker = \"worker\";\nstatic constexpr const char* kDriver = \"driver\";\n// attributes\nstatic constexpr const char* kName = \"name\";\nstatic constexpr const char* kEnabled = \"enabled\";\nstatic constexpr const char* kPort = \"port\";\nstatic constexpr const char* kDriverIp = \"driver_ip\";\nstatic constexpr const char* kDriverPort = \"driver_port\";\nstatic constexpr const char* kRemoteAccess = \"remote_access\";\nstatic constexpr const char* kServerIpAddress = \"server_ip_address\";\n\n/**\n * @brief Read and parse YAML config files\n *\n */\nclass ConfigParser {\n public:\n struct SegmentConfig {\n struct EnabledSegments {\n std::vector names;\n };\n struct Worker {\n bool enabled = true;\n std::string name;\n int32_t port = 0;\n std::string driver_ip;\n int32_t driver_port = 0;\n };\n struct Driver {\n bool enabled = false;\n std::string name;\n int32_t port = 0;\n };\n EnabledSegments enabled_segments;\n Worker worker;\n Driver driver;\n bool enable_all_segments = true;\n };\n ConfigParser() {\n segment_control_ = std::make_shared();\n }\n /**\n * Main API\n */\n Expected setFilePath(const std::string& file_path);\n Expected setFilePath(int argc, char** argv);\n Expected> getSegmentConfig();\n\n private:\n std::string file_path_;\n std::shared_ptr segment_control_;\n\n private:\n std::string getExecutablePath();\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_CONFIG_PARSER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/driver.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_APPLICATION_DRIVER_HPP_\n#define NVIDIA_GXF_APPLICATION_DRIVER_HPP_\n\n#include \n#include \n\n#include \"gxf/app/segment.hpp\"\n#include \"gxf/std/graph_driver.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nclass Application;\n\n/**\n * @brief GraphDriver representation in Application API layer\n * It drives the execution of all remote GraphWorkers\n *\n */\nclass Driver {\n public:\n Driver(Application* owner, const std::string& name);\n\n std::string name() { return name_; }\n Expected setPort(uint32_t port) { port_ = port; return Success; }\n // commit the setup into GraphWorker\n Expected commit();\n private:\n Application* owner_;\n std::string name_;\n GraphEntityPtr driver_entity_;\n // core component\n Handle graph_driver_;\n // server interface object\n Handle server_;\n // client interface object\n Handle client_;\n\n // driver server's own port\n uint32_t port_;\n};\ntypedef std::shared_ptr DriverPtr;\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_APPLICATION_DRIVER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/entity_group.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_ENTITY_GROUP_HPP_\n#define NVIDIA_GXF_ENTITY_GROUP_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"gxf/app/graph_entity.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief A wrapper over EntityGroup C APIs to manage a programmable\n * entity group in C++ API layer\n *\n */\nclass EntityGroup {\n public:\n EntityGroup() = default;\n\n ~EntityGroup() = default;\n\n EntityGroup(const EntityGroup&) = delete;\n\n EntityGroup& operator=(const EntityGroup&) = delete;\n\n /**\n * @brief Creates a programmable entity group with the runtime context and sets its name\n *\n * @param context A valid GXF context\n * @param name Name of the graph entity\n */\n Expected setup(gxf_context_t context, const char* name);\n\n /**\n * @brief Add single entity into this entity group.\n * All Resouce components within the group will be automatically resolved to owner components\n * that has corresponding type of Resource members registered.\n *\n * @param GraphEntityPtr An entity in C++ API representation\n */\n Expected add(GraphEntityPtr entity);\n\n /**\n * @brief Add a list of entities into this entity group.\n * All Resouce components within the group will be automatically resolved to owner components\n * that has corresponding type of Resource members registered.\n *\n * @param entity_members A list of entities in C++ API representation\n */\n Expected add(std::vector entity_members);\n\n /**\n * @return This entity group ID.\n */\n gxf_uid_t gid() const { return gid_; }\n\n /**\n * @return This entity group name.\n */\n std::string name() const { return name_; }\n\n private:\n gxf_uid_t gid_{kNullUid};\n std::string name_;\n std::map entity_members_;\n};\n\ntypedef std::shared_ptr EntityGroupPtr;\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_ENTITY_GROUP_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/extension_manager.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_GRAPH_EXTENSION_MANAGER_HPP_\n#define NVIDIA_GXF_GRAPH_EXTENSION_MANAGER_HPP_\n\n#include \n#include \n#include // NOLINT\n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/std/extension.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief Loads extensions and allows to create instances of their components.\n *\n */\nclass ExtensionManager {\n public:\n ExtensionManager() = default;\n ~ExtensionManager() = default;\n\n ExtensionManager(const ExtensionManager&) = delete;\n ExtensionManager(ExtensionManager&&) = delete;\n ExtensionManager& operator=(const ExtensionManager&) = delete;\n ExtensionManager& operator=(ExtensionManager&&) = delete;\n\n // Loads a GXF extension from the given file\n Expected registerExtensions(gxf_context_t context);\n Expected load(const char* filename);\n Expected load(Extension* extension, void* handle = nullptr);\n Expected loadManifest(const char* filename);\n Expected unloadAll();\n\n // Gets list of TIDs for loaded Extensions.\n // [in/out] extension_num is for capacity of parameter extensions\n // [out] extensions is memory to write TIDs to\n Expected getExtensions(uint64_t* extension_count, gxf_tid_t* extensions);\n\n // Gets description for specified (loaded) extension and list of components It provides\n Expected getExtensionInfo(gxf_tid_t eid, gxf_extension_info_t* info);\n\n private:\n std::set handles_;\n std::map component_factory_;\n std::map extension_factory_;\n std::vector factories_;\n\n mutable std::shared_timed_mutex mutex_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_EXTENSION_MANAGER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/graph_entity.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_GRAPH_ENTITY_HPP_\n#define NVIDIA_GXF_GRAPH_ENTITY_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/app/arg.hpp\"\n#include \"gxf/app/arg_parse.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/std/clock.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/resources.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief A wrapper over nvidia::gxf::Entity to manage a programmable\n * graph entity.\n *\n */\nclass GraphEntity {\n public:\n GraphEntity() = default;\n\n ~GraphEntity() = default;\n\n GraphEntity(const GraphEntity&) = delete;\n\n GraphEntity& operator=(const GraphEntity&) = delete;\n\n /**\n * @brief Creates a programmable entity with the runtime context and sets its name\n *\n * @param context A valid GXF context\n * @param name Name of the graph entity\n */\n Expected setup(gxf_context_t context, const char* name) {\n const GxfEntityCreateInfo entity_create_info = {name, GXF_ENTITY_CREATE_PROGRAM_BIT};\n auto result = GxfCreateEntity(context, &entity_create_info, &eid_);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Failed to create entity [%s] with error %s\", name, GxfResultStr(result));\n return Unexpected{result};\n }\n GxfEntityRefCountInc(context, eid_);\n Entity::Own(context, eid_).map([&](Entity entity) { entity_ = std::move(entity); });\n return Success;\n }\n\n /**\n * @brief Creates a generic component of type T and sets the parameter values from Args\n * pack of args.\n *\n * Transmitters, Receivers, Clocks and Scheduling Term component names have to be unique.\n *\n * @tparam T Type of component. Must be derived from nvidia::gxf::Component\n * @param name Name of the component\n * @param args Args must be of type Arg\n * @return Handle Handle to newly created component. Null handle if component was not created.\n */\n template \n Handle add(const char* name = nullptr, Args && ... args) {\n std::vector arg_list;\n if constexpr (sizeof...(args) > 0) {\n arg_list = parseArgsOfType(std::forward(args)...);\n }\n return add(name, std::move(arg_list));\n }\n\n /**\n * @brief Creates a generic component of type T and sets the parameter values from arg_list.\n *\n * Transmitters, Receivers, Clocks and Scheduling Term component names have to be unique.\n *\n * @tparam T Type of component. Must be derived from nvidia::gxf::Component\n * @param name Name of the component\n * @param arg_list vector of Arg used for initializing the component's parameters.\n * @return Handle Handle to newly created component. Null handle if component was not created.\n */\n template \n Handle add(const char* name, std::vector arg_list) {\n auto maybe_component = addComponent(name, arg_list);\n if (!maybe_component) { return Handle::Null(); }\n return maybe_component.value();\n }\n\n /**\n * @brief Finds all components of given type. Returns an empty vector if component is not found\n *\n * @tparam T Type of component to search for\n * @return FixedVector, N> List of handles to components of the same type\n */\n template \n FixedVector, N> findAll() const {\n auto maybe_result = entity_.findAll();\n return maybe_result ? maybe_result.value() : FixedVector, N>();\n }\n\n /**\n * @brief Gets a component by type and name. Returns null handle if no such component.\n *\n * @tparam T Type of component to search for\n * @param name Name of the component to look for\n * @return Handle Handle to component, if component is found. Null handle if\n * no such component.\n */\n template \n Handle get(const char* name = nullptr) const {\n auto maybe_handle = entity_.get(name);\n if (!maybe_handle) {\n GXF_LOG_WARNING(\"Failed to find component [%s] with name [%s] in entity [%s] with error %s\",\n TypenameAsString(), name, entity_.name(),\n GxfResultStr(maybe_handle.error()));\n return Handle::Null();\n }\n return maybe_handle.value();\n }\n\n /**\n * @brief Get a component by type and name. Returns an Unexpected in the case that the\n * component is not found. Unlike `get` no error is logged if a component is not found.\n *\n * @tparam T Type of component to search for\n * @param name Name of the component to look for\n * @return Expected> Handle to the component, if component is found.\n * Otherwise, an Unexpected is returned.\n */\n template \n Expected> try_get(const char* name = nullptr) const {\n auto maybe_handle = entity_.get(name);\n if (!maybe_handle) { return Unexpected{GXF_ENTITY_COMPONENT_NOT_FOUND}; }\n return maybe_handle.value();\n }\n\n /**\n * @brief Gets a component by type and name. Returns null handle if no such component.\n *\n * @param type_name Fully qualified C++ type name of the component to search for\n * @param name Name of the component to look for\n * @return Handle Handle to component, if component is found. Null handle if\n * no such component.\n */\n Handle get(const char* type_name, const char* name = nullptr) const;\n\n /**\n * @brief Get a component by type and name. Returns an Unexpected in the case that the\n * component is not found. Unlike `get` no error is logged if a component is not found.\n *\n * @param type_name Fully qualified C++ type name of the component to search for\n * @param name Name of the component to look for\n * @return Expected> Handle to the component, if component is found.\n * Otherwise, an Unexpected is returned.\n */\n Expected> try_get(const char* type_name, const char* name = nullptr) const;\n\n /**\n * @brief Adds a codelet of type T with given name and sets the parameter values from Args\n *\n * @tparam T Type of codelet. Must be derived from nvidia::gxf::Codelet\n * @param name name of the codelet\n * @param args Args must be of type Arg\n * @return Handle Handle to newly created component\n */\n template \n Handle addCodelet(const char* name = nullptr, Args... args) {\n static_assert(std::is_base_of::value, \"Requested type is not a codelet\");\n if (!codelet_.is_null()) {\n GXF_LOG_ERROR(\"Graph Entity is already configured with a codelet [%s]\", codelet_->name());\n return Handle::Null();\n }\n\n auto codelet = add(name, args...);\n if (!codelet) { return codelet; }\n\n codelet_ = codelet;\n return codelet;\n }\n\n /**\n * @brief Adds a codelet with a given C++ type name.\n *\n * @param type_name The fully qualified C++ type name of the codelet component\n * @param name Name of the codelet\n * @param arg_list Arguments for the codelet\n * @return Handle Handle to newly created codelet component\n */\n Handle addCodelet(const char* type_name, const char* name = nullptr,\n const std::vector& arg_list = {});\n\n /**\n * @brief Adds a component with a given C++ type name.\n *\n * @param type_name The fully qualified C++ type name of the component\n * @param name Name of the component\n * @param arg_list Arguments for the component\n * @return Handle Handle to newly created component\n */\n Handle addComponent(const char* type_name, const char* name = nullptr,\n const std::vector& arg_list = {});\n\n /**\n * @brief Adds a component of Clock type T and sets the parameter values from Args\n *\n * @tparam T Type of clock. Must be derived from nvidia::gxf::Clock.\n * @param name Name of the clock\n * @param args Args must be of type Arg\n * @return Handle Handle to newly created clock component\n */\n template \n Handle addClock(const char* name = nullptr, Args... args) {\n static_assert(std::is_base_of::value, \"Requested type is not a clock\");\n auto clock = add(name, args...);\n return clock;\n }\n\n /**\n * @brief Adds a clock component with a given C++ type name.\n *\n * @param type_name The fully qualified C++ type name of the clock\n * @param name Name of the clock\n * @param arg_list Arguments for the clock component\n * @return Handle Handle to newly created clock\n */\n Handle addClock(const char* type_name, const char* name = nullptr,\n const std::vector& arg_list = {});\n\n /**\n * @brief Get the Clock object from a graph entity. Returns null handle if no clock component\n * has been created yet. Returns the first clock if no component name is provided. If name is\n * provided, exact instance of the clock is returned if found else a Null handle.\n *\n * @param name Name of the clock component to lookup\n * @return Handle\n */\n Handle getClock(const char* name = nullptr);\n\n /**\n * @brief Adds a component of SchedulingTerm type T and sets the parameter values from Args\n *\n * @tparam T Type of SchedulingTerm. Must be derived from nvidia::gxf::SchedulingTerm\n * @param name name of the scheduling term\n * @param args Args must be of type Arg\n * @return Handle Handle to newly created scheduling term component\n */\n template \n Handle addSchedulingTerm(const char* name = nullptr, Args... args) {\n static_assert(std::is_base_of::value,\n \"Requested type is not a SchedulingTerm\");\n auto term = add(name, args...);\n return term;\n }\n\n /**\n * @brief Adds a scheduling term component with a given C++ type name.\n *\n * @param type_name The fully qualified C++ type name of the scheduling term\n * @param name Name of the scheduling term\n * @return Handle Handle to newly created scheduling term\n */\n Handle addSchedulingTerm(const char* type_name, const char* name = nullptr,\n const std::vector& arg_list = {});\n\n /**\n * @brief Adds a component of Transmitter type T with name and sets the parameter values from\n * Args\n *\n * Name of the transmitter should match the parameter name of the underlying codelet\n * The name of the transmitter component is updated based on the parameter rank info.\n * A Downstream receptive scheduling term is also added to monitor the transmitter component\n *\n * If codelet parameter is a scalar, name of the transmitter is also same as the parameter key\n * Parameter> | name - \"key\"\n *\n * If codelet parameter is a vector/array, the name of the transmitter component is key_%d where\n * 'd' is the index of this transmitter in the codelet parameter.\n * Parameter> | name - \"key_0\", \"key_1\", \"key_2\"\n *\n * @tparam T Type of Transmitter. Must be derived from nvidia::gxf::Transmitter\n * @param name Name of the transmitter component\n * @param omit_term Boolean flag controlling whether or not a default downstream receptive\n * scheduling term is added. If true, no scheduling term is added.\n * @param args Args must be of type Arg\n * @return Handle Handle to newly created transmitter component\n */\n template \n Handle addTransmitter(const char* name, bool omit_term = false, Args... args) {\n static_assert(std::is_base_of::value, \"Requested type is not a Transmitter\");\n auto maybe_tx_name = formatTxName(name);\n if (!maybe_tx_name) { return Handle::Null(); }\n auto tx_name = maybe_tx_name.value();\n\n auto tx = add(tx_name.c_str(), args...);\n if (!tx) { return tx; }\n\n if (!omit_term) {\n // auto adds a downstream receptive scheduling term\n auto term = this->add(tx_name.c_str());\n term->setTransmitter(tx);\n }\n\n std::string full_name = std::string(this->name()) + \"/\" + tx_name;\n auto result = updatePort(name, full_name);\n if (!result) {\n GXF_LOG_ERROR(\"Failed to add Transmitter [%s] with error [%s]\", tx_name.c_str(),\n GxfResultStr(result.error()));\n }\n\n return tx;\n }\n\n /**\n * @brief Adds a component of Transmitter of the corresponding type_name.\n * Name of the transmitter should match the parameter name of the underlying codelet\n * The name of the transmitter component is updated based on the parameter rank info.\n *\n * If codelet parameter is a scalar, name of the transmitter is also same as the parameter key\n * Parameter> | name - \"key\"\n *\n * If codelet parameter is a vector/array, the name of the transmitter component is key_%d where\n * 'd' is the index of this transmitter in the codelet parameter.\n * Parameter> | name - \"key_0\", \"key_1\", \"key_2\"\n *\n * @param type_name The fully qualified C++ type name of the transmitter component\n * @param name Name of the transmitter component\n * @param arg_list Arguments for the transmitter component\n * @param omit_term Boolean flag controlling whether or not a default downstream receptive\n * scheduling term is added. If true, no scheduling term is added.\n * @return Handle Handle to newly created transmitter component\n */\n Handle addTransmitter(const char* type_name, const char* name = nullptr,\n const std::vector& arg_list = {}, bool omit_term = false);\n\n /**\n * @brief Transmitter component lookup using name\n *\n * @param name name of a transmitter component which has been previously created\n * @return Handle Handle to transmitter component if found, Null handle if\n * no such component.\n */\n Handle getTransmitter(const char* name) {\n for (auto it = tx_queues_.begin(); it != tx_queues_.end(); ++it) {\n if (!strcmp(it->second->name(), name)) { return it->second; }\n }\n return Handle::Null();\n }\n\n /**\n * @brief Adds a component of Receiver type T with name and sets the parameter values from Args\n *\n * Name of the receiver should match the parameter name of the underlying codelet\n * The name of the receiver component is updated based on the parameter rank info.\n * A Message available scheduling term is also added to monitor the receiver component\n *\n * If codelet parameter is a scalar, name of the receiver is also same as the parameter key\n * Parameter> | name - \"key\"\n *\n * If codelet parameter is a vector/array, the name of the receiver component is key_%d where\n * 'd' is the index of this receiver in the codelet parameter.\n * Parameter> | name - \"key_0\", \"key_1\", \"key_2\"\n *\n * @tparam T Type of Receiver. Must be derived from nvidia::gxf::Receiver\n * @param name Name of the receiver component\n * @param omit_term Boolean flag controlling whether or not a default message available\n * scheduling term is added. If true, no scheduling term is added.\n * @param args Args must be of type Arg\n * @return Handle Handle to newly created receiver component\n */\n template \n Handle addReceiver(const char* name, bool omit_term = false, Args... args) {\n static_assert(std::is_base_of::value, \"Requested type is not a Receiver\");\n auto maybe_rx_name = formatRxName(name);\n if (!maybe_rx_name) { return Handle::Null(); }\n auto rx_name = maybe_rx_name.value();\n\n auto rx = add(rx_name.c_str(), args...);\n if (!rx) { return rx; }\n\n if (!omit_term) {\n // auto adds a message available scheduling term\n auto term = this->add(rx_name.c_str());\n term->setReceiver(rx);\n }\n\n std::string full_name = std::string(this->name()) + \"/\" + rx_name;\n auto result = updatePort(name, full_name);\n if (!result) {\n GXF_LOG_ERROR(\"Failed to add Receiver [%s] with error [%s]\", rx_name.c_str(),\n GxfResultStr(result.error()));\n }\n\n return rx;\n }\n\n /**\n * @brief Adds a component of Receiver of the corresponding type_name.\n * Name of the receiver should match the parameter name of the underlying codelet\n * The name of the receiver component is updated based on the parameter rank info.\n *\n * If codelet parameter is a scalar, name of the receiver is also same as the parameter key\n * Parameter> | name - \"key\"\n *\n * If codelet parameter is a vector/array, the name of the receiver component is key_%d where\n * 'd' is the index of this receiver in the codelet parameter.\n * Parameter> | name - \"key_0\", \"key_1\", \"key_2\"\n *\n * @param type_name The fully qualified C++ type name of the receiver component\n * @param name Name of the receiver component\n * @param arg_list Arguments for the receiver component\n * @param omit_term Boolean flag controlling whether or not a default message available\n * scheduling term is added. If true, no scheduling term is added.\n * @return Handle Handle to newly created receiver component\n */\n Handle addReceiver(const char* type_name, const char* name = nullptr,\n const std::vector& arg_list = {}, bool omit_term = false);\n\n /**\n * @brief Receiver component lookup using name\n *\n * @param name name of a receiver component which has been previously created\n * @return Handle Handle to receiver component if found, Null handle if\n * no such component.\n */\n Handle getReceiver(const char* name) {\n for (auto it = rx_queues_.begin(); it != rx_queues_.end(); ++it) {\n if (!strcmp(it->second->name(), name)) { return it->second; }\n }\n return Handle::Null();\n }\n\n /**\n * @brief Update the capacity and min_size parameter of a transmitter and its corresponding\n * downstream receptive scheduling term\n *\n * @param name Name of the transmitter component\n * @param capacity capacity of the transmitter to be set\n * @param policy policy of the transmitter to be set\n * @param min_size min size of the downstream receptive term to be set\n * @return Expected On success the function returns Success\n */\n Expected configTransmitter(const char* name, uint64_t capacity, uint64_t policy,\n uint64_t min_size) {\n if (tx_queues_.find(name) == tx_queues_.end()) {\n GXF_LOG_ERROR(\"Transmitter [%s] is not found in entity [%s]\", name, this->name());\n return Unexpected{GXF_ENTITY_COMPONENT_NOT_FOUND};\n }\n\n Handle tx = tx_queues_.at(name);\n tx->setParameter(\"capacity\", capacity);\n tx->setParameter(\"policy\", policy);\n\n if (terms_.find(name) == terms_.end()) {\n GXF_LOG_ERROR(\"Scheduling term [%s] is not found in entity [%s]\", name, this->name());\n return Unexpected{GXF_ENTITY_COMPONENT_NOT_FOUND};\n }\n\n Handle term = terms_.at(name);\n term->setParameter(\"min_size\", min_size);\n\n return Success;\n }\n\n /**\n * @brief Update the capacity and min_size parameter of a receiver and its corresponding\n * message available scheduling term\n *\n * @param name Name of the receiver component\n * @param capacity capacity of the receiver to be set\n * @param policy policy of the receiver to be set\n * @param min_size min size of the message available term to be set\n * @return Expected On success the function returns Success\n */\n Expected configReceiver(const char* name, uint64_t capacity, uint64_t policy,\n uint64_t min_size) {\n if (rx_queues_.find(name) == rx_queues_.end()) {\n GXF_LOG_ERROR(\"Receiver [%s] is not found in entity [%s]\", name, this->name());\n return Unexpected{GXF_ENTITY_COMPONENT_NOT_FOUND};\n }\n\n Handle rx = rx_queues_.at(name);\n rx->setParameter(\"capacity\", capacity);\n rx->setParameter(\"policy\", policy);\n\n if (terms_.find(name) == terms_.end()) {\n GXF_LOG_ERROR(\"Scheduling term [%s] is not found in entity [%s]\", name, this->name());\n return Unexpected{GXF_ENTITY_COMPONENT_NOT_FOUND};\n }\n\n Handle term = terms_.at(name);\n term->setParameter(\"min_size\", min_size);\n\n return Success;\n }\n\n Expected activate() { return entity_.activate(); }\n\n Expected deactivate() { return entity_.deactivate(); }\n\n gxf_context_t context() const { return entity_.context(); }\n\n gxf_uid_t eid() const { return entity_.eid(); }\n\n bool is_null() const { return entity_.is_null(); }\n\n Handle get_codelet() { return codelet_; }\n\n /**\n * @brief The name of the entity or empty string if no name has been given to the entity.\n *\n * @return const char* pointer to name of the entity\n */\n const char* name() const { return entity_.name(); }\n\n /**\n * @brief Given a name for a transmitter to be connected to the codelet, return a formatted\n * string back which can be used for a new transmitter component creation\n * If the codelet's tx parameter is a scalar, the tx name is the same as the parameter key\n * If the codelet's tx parameter is a vector, the tx name would be \"key_0\", \"key_1\" ...\n *\n * @param tx_name name of transmitter component\n * @return Expected formatted name of transmitter component\n */\n Expected formatTxName(const char* tx_name);\n\n /**\n * @brief Given a name for a receiver to be connected to the codelet, return a formatted\n * string back which can be used for a new receiver component creation\n * If the codelet's rx parameter is a scalar, the rx name is the same as the parameter key\n * If the codelet's rx parameter is a vector, the rx name would be \"key_0\", \"key_1\" ...\n *\n * @param rx_name name of receiver component\n * @return Expected formatted name of receiver component\n */\n Expected formatRxName(const char* rx_name);\n\n Expected updatePort(const char* key, std::string value);\n\n private:\n // Creates a generic component of type T and sets the parameter values from arg_list.\n //\n // Transmitters, Receivers, Clocks and Scheduling Term component names have to be unique.\n // If the component type has been registered on any of the extensions which have been loaded, the\n // new type would be registered to a runtime extension.\n template \n Expected> addComponent(const char* name = nullptr,\n const std::vector& arg_list = {}) {\n static_assert(std::is_base_of::value, \"Requested type is not a component\");\n // Check if another component with same name and base type exists\n // return failure if it exists, otherwise proceed with component creation\n if constexpr (std::is_base_of::value) {\n if (!codelet_.is_null() && !strcmp(codelet_->name(), name)) {\n GXF_LOG_ERROR(\"Codelet with same name [%s] already exists in entity [%s]\", name,\n entity_.name());\n return Unexpected{GXF_FAILURE};\n }\n } else if constexpr (std::is_base_of::value) {\n if (terms_.find(name) != terms_.end()) {\n GXF_LOG_ERROR(\"Scheduling term with same name [%s] already exists in entity [%s]\", name,\n entity_.name());\n return Unexpected{GXF_FAILURE};\n }\n } else if constexpr (std::is_base_of::value) {\n if (tx_queues_.find(name) != tx_queues_.end()) {\n GXF_LOG_ERROR(\"Transmitter with same name [%s] already exists in entity [%s]\", name,\n entity_.name());\n return Unexpected{GXF_FAILURE};\n }\n } else if constexpr (std::is_base_of::value) {\n if (rx_queues_.find(name) != rx_queues_.end()) {\n GXF_LOG_ERROR(\"Receiver with same name [%s] already exists in entity [%s]\", name,\n entity_.name());\n return Unexpected{GXF_FAILURE};\n }\n } else if constexpr (std::is_base_of::value) {\n if (clocks_.find(name) != clocks_.end()) {\n GXF_LOG_ERROR(\"Clock with same name [%s] already exists in entity [%s]\", name,\n entity_.name());\n return Unexpected{GXF_FAILURE};\n }\n }\n\n Expected> maybe_component = entity_.add(name);\n if (!maybe_component) {\n GXF_LOG_ERROR(\"Failed to add handle for component named [%s] to entity [%s] with error %s\",\n name, entity_.name(), GxfResultStr(maybe_component.error()));\n return ForwardError(maybe_component);\n }\n Handle component = maybe_component.value();\n\n for (auto arg : arg_list) { applyArg(component, arg); }\n\n if constexpr (std::is_base_of::value) {\n if (!codelet_.is_null()) {\n GXF_LOG_DEBUG(\n \"Graph Entity is already configured with a codelet [%s]. New codelet \"\n \"will be created but not managed by entity [%s]\",\n codelet_->name(), entity_.name());\n } else {\n codelet_ = component;\n }\n } else if constexpr (std::is_base_of::value) {\n terms_.emplace(name, component);\n } else if constexpr (std::is_base_of::value) {\n tx_queues_.emplace(name, component);\n } else if constexpr (std::is_base_of::value) {\n rx_queues_.emplace(name, component);\n } else if constexpr (std::is_base_of::value) {\n clocks_.emplace(name, component);\n }\n\n components_.emplace(component.get()->cid(), component);\n return component;\n }\n\n // Create a Handle of the specified type corresponding to a fully qualified C++ type name and\n // add it to the entity.\n template \n Expected> createHandle(const char* type_name, const char* name = nullptr) {\n gxf_tid_t tid;\n gxf_context_t context = entity_.context();\n\n gxf_result_t result = GxfComponentTypeId(context, type_name, &tid);\n if (!isSuccessful(result)) {\n GXF_LOG_ERROR(\"Typename [%s] not found. Is this type registered?\", type_name);\n return Unexpected{result};\n }\n\n auto maybe_untyped_handle = entity_.add(tid, name);\n if (!maybe_untyped_handle) {\n GXF_LOG_ERROR(\"Failed to add handle for [%s] to entity [%s] with error %s\", type_name,\n entity_.name(), GxfResultStr(maybe_untyped_handle.error()));\n return ForwardError(maybe_untyped_handle);\n }\n\n auto maybe_handle = Handle::Create(maybe_untyped_handle.value());\n if (!maybe_handle) {\n GXF_LOG_ERROR(\"Failed to convert untyped handle to handle with error %s\",\n GxfResultStr(maybe_handle.error()));\n return ForwardError(maybe_handle);\n }\n\n return maybe_handle.value();\n }\n\n // A single codelet per GraphEntity\n Handle codelet_{Handle::Null()};\n\n // global component lookup based on uid\n std::map> components_;\n\n // scheduling term component lookup by name\n std::map> terms_;\n\n // transmitter component lookup by name\n std::map> tx_queues_;\n\n // receiver component lookup by name\n std::map> rx_queues_;\n\n // clock component lookup by name\n std::map> clocks_;\n\n // resource lookup by name\n std::map> resources_;\n\n gxf_uid_t eid_{kNullUid};\n Entity entity_;\n};\n\ntypedef std::shared_ptr GraphEntityPtr;\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_ENTITY_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/graph_utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_GRAPH_UTILS_HPP_\n#define NVIDIA_GXF_GRAPH_UTILS_HPP_\n\n#include \n\nnamespace nvidia {\nnamespace gxf {\n\n\nstatic gxf_tid_t generate_tid() {\n std::random_device rd;\n std::mt19937_64 generator(rd());\n std::uniform_int_distribution dis(0, UINT64_MAX);\n\n // Generate two 64-bit random numbers to create a UUID\n uint64_t random1 = dis(generator);\n uint64_t random2 = dis(generator);\n\n // Combine the random numbers to create a UUID string\n std::string uuid_str = std::to_string(random1) + std::to_string(random2);\n GXF_LOG_VERBOSE(\"UUID generated %s\", uuid_str.c_str());\n\n return gxf_tid_t{random1, random2};\n}\n\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_UTILS_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/proxy_component.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_PROXY_COMPONENT_HPP_\n#define NVIDIA_GXF_PROXY_COMPONENT_HPP_\n\n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/expected_macro.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief A type to aid in lazy component creation by storing component type\n * and arg info\n *\n */\nclass ProxyComponent {\n public:\n ProxyComponent() {}\n ProxyComponent(const std::string& type_name, const std::string& component_name,\n const std::vector& args)\n : typename_(type_name), component_name_(component_name), args_(args) {}\n\n std::string type_name() const { return typename_; }\n\n std::string name() const { return component_name_; }\n\n std::vector args() const { return args_; }\n\n private:\n std::string typename_;\n std::string component_name_;\n std::vector args_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_PROXY_COMPONENT_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/segment.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_SEGMENT_HPP_\n#define NVIDIA_GXF_SEGMENT_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"gxf/app/arg.hpp\"\n#include \"gxf/app/arg_parse.hpp\"\n#include \"gxf/app/entity_group.hpp\"\n#include \"gxf/app/graph_entity.hpp\"\n#include \"gxf/app/graph_utils.hpp\"\n#include \"gxf/app/proxy_component.hpp\"\n#include \"gxf/core/expected_macro.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/std/default_extension.hpp\"\n#include \"gxf/std/resources.hpp\"\n#include \"gxf/std/scheduler.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief A entity - entity connection specified using tx and rx component names\n * tx - transmitter component name\n * rx - receiver component name\n * The queue names should match the parameter keys of the codelet in the corresponding GraphEntity\n * for a successful connection between the two graph entities.\n */\ntypedef struct PortPair {\n PortPair(std::string tx, std::string rx) : tx(tx), rx(rx) {}\n std::string tx;\n std::string rx;\n} PortPair;\n\n/**\n * @brief An open port in an segment is specified using entity and queue component names.\n * SegmentPort name is in the format \".\"\n * Entity Name - name of a graph entity created in the segment\n * Queue Name - tx or rx component name which should match the parameter keys of the codelet in\n * the corresponding GraphEntity for a successful connection\n */\n\ntypedef struct SegmentPort {\n auto split_string(std::string port_name) {\n std::string entity;\n std::string queue;\n\n // Find the position of the dot\n size_t index = port_name.find('.');\n if (index != std::string::npos) {\n entity = port_name.substr(0, index);\n queue = port_name.substr(index + 1);\n } else {\n GXF_LOG_ERROR(\n \"Invalid port name [%s]. Port names should follow [Entity.Queue] naming convention\",\n port_name.c_str());\n }\n\n return std::make_pair(entity, queue);\n }\n auto split_string2(std::string port_name) {\n size_t first_pivot = port_name.find(\".\");\n size_t second_pivot = port_name.substr(first_pivot + 1).find(\".\");\n size_t third_pivot = port_name.find_last_of(\".\");\n if (first_pivot == std::string::npos\n || second_pivot == std::string::npos\n || third_pivot == std::string::npos) {\n GXF_LOG_ERROR(\n \"Invalid port name [%s]. For port names with 3 dots, \"\n \"it should follow [Segment.Entity.Queue] naming convention\",\n port_name.c_str());\n }\n std::string segment = port_name.substr(0, first_pivot);\n std::string entity = port_name.substr(first_pivot + 1, second_pivot);\n std::string queue = port_name.substr(third_pivot + 1);\n return std::make_tuple(segment, entity, queue);\n }\n\n std::string to_string() {\n if (!segment.empty()) {\n return segment + \".\" + entity + \".\" + queue;\n } else {\n return entity + \".\" + queue;\n }\n }\n\n SegmentPort(std::string name) {\n int count = std::count(name.begin(), name.end(), '.');\n if (count == 2) {\n std::tie(segment, entity, queue) = split_string2(name);\n } else {\n std::tie(entity, queue) = split_string(name);\n }\n }\n std::string segment;\n std::string entity;\n std::string queue;\n\n bool operator==(const SegmentPort& other) const {\n return segment == other.segment && entity == other.entity && queue == other.queue;\n }\n} SegmentPort;\n\n\n/**\n * @brief A segment - segment connection specified using the segment port info\n * SegmentPort name is in the format \".\" where the queues are tx\n * or rx components.\n * tx - SegmentPort in the source segment\n * rx - SegmentPort in the sink segment\n *\n * The queue names should match the parameter keys of the codelet in the corresponding GraphEntity\n * for a successful connection between the two segments\n */\ntypedef struct SegmentPortPair {\n SegmentPortPair(std::string tx, std::string rx) : tx(tx), rx(rx) {}\n SegmentPort tx;\n SegmentPort rx;\n\n bool operator==(const SegmentPortPair& other) const {\n return tx == other.tx && rx == other.rx;\n }\n} SegmentPortPair;\n\n/**\n * @brief Enum representing the type of scheduler to be used in the application.\n * This enum is primarily used as an input to setScheduler api\n *\n */\nenum class SchedulerType: int8_t {\n kGreedy = 0,\n kMultiThread,\n KEventBased,\n};\n\nconst constexpr SchedulerType Greedy = SchedulerType::kGreedy;\nconst constexpr SchedulerType MultiThread = SchedulerType::kMultiThread;\nconst constexpr SchedulerType EventBased = SchedulerType::KEventBased;\n\n/**\n * @brief Segment is a group of graph entities created in a single GXF runtime context. A segment\n * will have its own scheduler. Graph entities in a segment are connected with each other via\n * double buffer transmitter and receiver components. A segment can also be connected other\n * segments via ucx transmitters and receivers.\n *\n * Segments are created and managed by the nvidia::gxf::Application class.\n */\nclass Segment {\n public:\n Segment() = default;\n\n virtual ~Segment() = default;\n\n Segment(Segment&&) = delete;\n\n Segment& operator=(Segment&&) = delete;\n\n Segment(const Segment&) = delete;\n\n Segment& operator=(const Segment&) = delete;\n\n virtual void compose() {}\n\n /**\n * @brief Creates a graph entity with a codelet of type CodeletT along with a parameter pack of\n * Arg & ProxyComponent. The codelet component will be used to auto populate connection queues and\n * their corresponding scheduling terms. Args can be used to specify a variable list of components to be\n * created along with the codelet in the graph entity. Args can also be used to specify a variable list\n * of Arg type to update any parameter values of the codelet\n *\n * @tparam CodeletT Codelet component to be added in the Graph Entity\n * @tparam Args Pack of Arg or ProxyComponent objects\n * @param name Name of the graph entity\n * @param args Pack of Arg or ProxyComponent objects\n * @return GraphEntityPtr A newly created graph entity object with the requested components.\n */\n template \n GraphEntityPtr makeEntity(const char* name, Args... args) {\n static_assert(std::is_base_of::value, \"Requested type is not a Codelet\");\n gxf_tid_t tid;\n gxf_result_t result = GxfComponentTypeId(context_, TypenameAsString(), &tid);\n if (result == GXF_FACTORY_UNKNOWN_CLASS_NAME) {\n // dynamically register the new component\n auto result = registerCodelet();\n if (result != GXF_SUCCESS) { return nullptr; }\n }\n\n auto entity = createGraphEntity(name);\n auto codelet = entity->addCodelet(name);\n\n if constexpr (sizeof...(args) > 0) {\n // First create all proxy components\n std::vector proxy_list = parseArgsOfType(args...);\n for (auto proxy : proxy_list) { createFromProxy(proxy, entity); }\n\n // parse all codelet args\n std::vector arg_list = parseArgsOfType(args...);\n\n // filter all proxy component args and create them\n auto proxy_args = filterProxyComponents(arg_list);\n for (auto arg : proxy_args) {\n auto proxy = arg.as();\n auto handle = createFromProxy(proxy, entity);\n applyArg(codelet, Arg(arg.key(), handle));\n }\n\n for (auto arg : arg_list) { applyArg(codelet, arg); }\n }\n\n return entity;\n }\n\n\n /**\n * @brief Creates a graph entity without a codelet and with a parameter pack of Arg\n * & ProxyComponent. Args can be used to specify a variable list of components to be\n * created along with the graph entity.\n *\n * @tparam Args Pack of Arg or ProxyComponent objects\n * @param name Name of the graph entity\n * @param args Pack of Arg or ProxyComponent objects\n * @return GraphEntityPtr A newly created graph entity object with the requested components.\n */\n template \n GraphEntityPtr makeEntity(const char* name, Args... args) {\n auto entity = createGraphEntity(name);\n\n if constexpr (sizeof...(args) > 0) {\n // First create all proxy components\n std::vector proxy_list = parseArgsOfType(args...);\n for (auto proxy : proxy_list) { createFromProxy(proxy, entity); }\n }\n\n return entity;\n }\n\n EntityGroupPtr makeEntityGroup(const char* name,\n const std::vector& entity_members = {}) {\n auto entity_group = createEntityGroup(name);\n entity_group->add(entity_members);\n\n return entity_group;\n }\n\n /**\n * @brief Creates a scheduling term of requested type and applies parameter component values\n * from a parameter pack of arguments. This api does not create the requested gxf native component.\n * A Proxy component value is returned which has the type info and arg list needed to create this\n * scheduling term. createFromProxy() api is used to create this component given any specific GraphEntity.\n *\n * @tparam T Type of GXF scheduling term. Type must be derived from nvidia::gxf::SchedulingTerm type.\n * @param name name of the component\n * @param args Parameter pack of arguments / parameter values to be applied to the component\n * @return ProxyComponent\n */\n template \n ProxyComponent makeTerm(const char* name, Args... args) {\n static_assert(std::is_base_of::value,\n \"Requested type is not a SchedulingTerm\");\n std::vector arg_list;\n const std::string type_name(TypenameAsString());\n if constexpr (sizeof...(args) > 0) { arg_list = parseArgsOfType(args...); }\n return ProxyComponent(type_name, name, arg_list);\n }\n\n /**\n * @brief Creates a resource of requested type and applies parameter component values\n * from a parameter pack of arguments. This api does not create the requested gxf native component.\n * A Proxy component value is returned which has the type info and arg list needed to create this\n * resource. createFromProxy() api is used to create this component given any specific GraphEntity.\n *\n * @tparam T Type of GXF resource. Type must be derived from nvidia::gxf::ResourceBase type.\n * @param name name of the component\n * @param args Parameter pack of arguments / parameter values to be applied to the component\n * @return ProxyComponent\n */\n template \n ProxyComponent makeResource(const char* name, Args... args) {\n // TODO(chandrahasj) Enable this check when allocator\n // types have been updated with resource base type\n // static_assert(std::is_base_of::value,\n // \"Requested type is not a Resource\");\n std::vector arg_list;\n const std::string type_name(TypenameAsString());\n if constexpr (sizeof...(args) > 0) { arg_list = parseArgsOfType(args...); }\n return ProxyComponent(type_name, name, arg_list);\n }\n\n /**\n * @brief Adds a clock component to the segment and applies parameter component values\n * from a parameter pack of arguments.\n *\n * @tparam T Type of GXF clock component. Type must be derived from nvidia::gxf::Clock type.\n * @param name Name of the clock component\n * @param args Parameter pack of arguments / parameter values to be applied to the component\n * @return Handle Handle to newly created clock component. Null handle if component was not\n * created.\n */\n template \n Handle setClock(const char* name, Args... args) {\n static_assert(std::is_base_of::value, \"Requested type is not a Clock\");\n if (!clock_entity_) { clock_entity_ = createGraphEntity(\"ClockEntity_\" + name_); }\n\n auto clock = clock_entity_->add(name);\n std::vector arg_list;\n if constexpr (sizeof...(args) > 0) { arg_list = parseArgsOfType(args...); }\n for (auto arg : arg_list) { applyArg(clock, arg); }\n return clock;\n }\n\n /**\n * @brief Adds a scheduler component to the segment and applies parameter component values\n * from a parameter pack of arguments.\n *\n * @tparam T Type of GXF scheduler component. Type must be derived from nvidia::gxf::Scheduler type.\n * @param args Parameter pack of arguments / parameter values to be applied to the component\n * @return Handle Handle to newly created scheduler component. Null handle if component was not\n * created.\n */\n template \n Handle setScheduler(Args... args) {\n std::vector arg_list;\n if constexpr (sizeof...(args) > 0) { arg_list = parseArgsOfType(args...); }\n\n return setScheduler(schedulerType, arg_list);\n }\n\n /**\n * @brief Add a scheduler to the segment based on the input SchedulerType enum. If the segment contains\n * a clock component, the same component will be reused to configure the scheduler. If no clock components\n * are found in the segment, a new RealTimeClock component will be added to the segment.\n *\n * @param scheduler Type of the scheduler to be added. One of kGreedy, kMultithread or kEventBased\n * @return Handle Handle to newly created scheduler component. Null handle if component was not\n * created.\n */\n Handle setScheduler(const SchedulerType& scheduler, std::vector arg_list = {});\n\n /**\n * @brief Adds a double buffer queue based connection between two entities with\n * 1:1 tx and rx connectivity.\n *\n * @param source Origin graph entity for the connection\n * @param target Destination graph entity for the connection\n * @return Expected On success the function returns Success\n */\n virtual Expected connect(GraphEntityPtr& source, GraphEntityPtr& target);\n\n /**\n * @brief Adds a single double buffer queue based connection between two entities\n * with a port pair specified.\n *\n * @param source Origin graph entity for the connection\n * @param target Destination graph entity for the connection\n * @param port_pair Port pair containing info of connection to be created\n * @return Expected On success the function returns Success\n */\n virtual Expected connect(GraphEntityPtr& source, GraphEntityPtr& target,\n PortPair port_pair);\n\n\n /**\n * @brief Adds multiple double buffer queue based connections between two entities\n * with many : many tx and rx. Connections between two graph entities are created\n * sequentially.\n *\n * @param source Origin graph entity for the connection\n * @param target Destination graph entity for the connection\n * @param port_pairs List of port pairs containing info of connections to be created\n * @return Expected On success the function returns Success\n */\n virtual Expected connect(GraphEntityPtr& source, GraphEntityPtr& target,\n std::vector port_pairs);\n /**\n * @brief Get the Entity object with given name. A nullptr is returned if entity is\n * not found.\n *\n * @param name Name of the graph entity. API is Case sensitive.\n * @return std::shared_ptr Pointer to underlying graph entity object\n */\n std::shared_ptr getEntity(const char* name) {\n for (auto& [uid, entity] : entities_) {\n if (std::strcmp(name, entity->name()) == 0) { return entity; }\n }\n GXF_LOG_ERROR(\"Graph Entity [%s] not found\", name);\n return nullptr;\n }\n\n /**\n * @brief Fetch the name of the segment\n *\n * @return const char* pointer to name of the segment\n */\n const char* name() const { return name_.c_str(); }\n\n /**\n * @brief Fetch the context of a segment\n *\n * @return gxf_context_t\n */\n gxf_context_t context() { return context_; }\n\n /**\n * @brief Activates all the graph entities in the segment\n *\n * @return Expected On success the function returns Success\n */\n Expected activate() {\n GXF_LOG_INFO(\"Activating segment [%s] ....\", name_.c_str());\n gxf_result_t result = GxfGraphActivate(context_);\n return result == GXF_SUCCESS ? Success : Unexpected{result};\n }\n\n /**\n * @brief Deactivates all the graph entities in the segment\n *\n * @return Expected On success the function returns Success\n */\n Expected deactivate() {\n GXF_LOG_INFO(\"Deactivating segment [%s] ....\", name_.c_str());\n gxf_result_t result = GxfGraphDeactivate(context_);\n return result == GXF_SUCCESS ? Success : Unexpected{result};\n }\n\n /**\n * @brief A blocking api to run the segment. This thread is blocked (sleeping)\n * until the segment execution is complete.\n *\n * @return Expected On success the function returns Success\n */\n Expected run() {\n GXF_LOG_INFO(\"Running segment [%s] ....\", name_.c_str());\n gxf_result_t result = GxfGraphRun(context_);\n return result == GXF_SUCCESS ? Success : Unexpected{result};\n }\n\n /**\n * @brief A non blocking api to execute a segment. API returns immediately after\n * starting the segment execution. wait() can be used to wait until execution\n * has finished.\n * @return Expected On success the function returns Success\n */\n Expected runAsync() {\n GXF_LOG_INFO(\"Running segment [%s] ....\", name_.c_str());\n gxf_result_t result = GxfGraphRunAsync(context_);\n return result == GXF_SUCCESS ? Success : Unexpected{result};\n }\n\n /**\n * @brief A non blocking api to stop a previously running segment. Segment is not guaranteed\n * to have stopped when this api returns. wait() can be used to wait until the execution\n * has finished.\n *\n * @return Expected On success the function returns Success\n */\n Expected interrupt() {\n GXF_LOG_INFO(\"Interrupting segment [%s] ....\", name_.c_str());\n gxf_result_t result = GxfGraphInterrupt(context_);\n return result == GXF_SUCCESS ? Success : Unexpected{result};\n }\n\n /**\n * @brief A blocking API to wait until the segment execution has completed.\n *\n * @return gxf_result_t On success the function returns GXF_SUCCESS.\n */\n Expected wait() {\n GXF_LOG_INFO(\"Waiting on segment [%s]....\", name_.c_str());\n gxf_result_t result = GxfGraphWait(context_);\n return result == GXF_SUCCESS ? Success : Unexpected{result};\n }\n\n /**\n * @brief Sets the severity level of the logs (corresponding to GXF_LOG_* logging macros)\n * for a segment\n *\n * @param severity a valid severity level as defined in `gxf_severity_t`. Logs corresponding to\n * any level <= severity will be logged.\n * @return gxf_result_t On success the function returns GXF_SUCCESS.\n */\n gxf_result_t setSeverity(gxf_severity_t severity) { return GxfSetSeverity(context_, severity); }\n\n /**\n * @brief Saves the segment information containing entities, components and their corresponding\n * parameter values in a yaml representation\n *\n * @param filepath path to save the resulting graph yaml file\n * @return Expected On success the function returns Success\n */\n Expected saveToFile(const char* filepath) {\n gxf_result_t code = GxfGraphSaveToFile(context_, filepath);\n return ExpectedOrCode(code);\n }\n\n /**\n * @brief Loads parameters for graph entities composed in the segment / application.\n * YAML file follows the GXF graph specification\n *\n * @param filepath path to a valid parameters file\n * @return Expected On success the function returns Success\n */\n Expected loadParameterFile(const char* filepath) {\n gxf_result_t code = GxfGraphLoadFile(context_, filepath);\n return ExpectedOrCode(code);\n }\n\n /**\n * @brief Create a Network Context in the segment which can be used by UCX Connections\n * added in the application. A new graph entity with the name \"NetworkContext\" will be added\n * to the segment context with a UcxContext component and a corresponding entity and component\n * serializers\n *\n * @return Expected On success the function returns Success\n */\n Expected createNetworkContext();\n\n /**\n * @brief Creates a component in graph entity based on the type information from the ProxyComponent\n *\n * @param component A proxy component object\n * @param entity A pointer to graph entity to be used for creating the component\n * @return Handle Handle to newly created component\n */\n Handle createFromProxy(ProxyComponent& component, GraphEntityPtr& entity);\n\n /**\n * @brief This function is expected to be called by the application layer to assign a context to the\n * segment and a runtime extension for on the fly registration of components\n *\n * @param segment_context A valid GXF context to be assigned to the segment\n * @param name A valid name for the segment\n * @param runtime_ext Pointer to a GXF extension which can be used to register any components at runtime\n * @return Expected On success the function returns Success\n */\n Expected setup(gxf_context_t segment_context, const char* name,\n std::shared_ptr runtime_ext) {\n name_.assign(name);\n context_ = segment_context;\n runtime_ext_ = runtime_ext;\n is_setup_ = true;\n return Success;\n }\n\n Expected setName(const char* name) {\n name_ = name;\n return Success;\n }\n\n Expected checkConfiguration() { return Success; }\n\n protected:\n /**\n * @brief Creates a programmable graph entity with the given name\n *\n * @param name Name of the graph entity\n * @return GraphEntityPtr Pointer to newly created entity\n */\n GraphEntityPtr createGraphEntity(std::string name) {\n GXF_LOG_DEBUG(\"Creating graph entity [%s]\", name.c_str());\n auto entity = std::make_shared();\n if (!entity->setup(context_, name.c_str())) {\n return nullptr;\n }\n entities_.emplace(entity->eid(), entity);\n return entity;\n }\n\n /**\n * @brief Creates a programmable graph entity group with the given name\n *\n * @param name Name of the graph entity\n * @return EntityGroupPtr Pointer to newly created entity group\n */\n EntityGroupPtr createEntityGroup(std::string name) {\n GXF_LOG_DEBUG(\"Creating graph entity group [%s]\", name.c_str());\n auto entity_group = std::make_shared();\n if (!entity_group->setup(context_, name.c_str())) {\n return nullptr;\n }\n entity_groups_.emplace(entity_group->gid(), entity_group);\n return entity_group;\n }\n\n // Registers a new codelet type with the runtime extension\n template \n gxf_result_t registerCodelet() {\n static_assert(std::is_base_of::value, \"Requested type is not a Codelet\");\n gxf_tid_t new_tid = generate_tid();\n auto result = runtime_ext_->add(new_tid, TypenameAsString(),\n TypenameAsString(), TypenameAsString());\n if (!result) { return ToResultCode(result); }\n return GxfRegisterComponentInExtension(context_, new_tid, runtime_ext_->tid());\n }\n\n // Extension to register components on the fly\n std::shared_ptr runtime_ext_;\n std::map entities_;\n std::map entity_groups_;\n GraphEntityPtr scheduler_entity_;\n GraphEntityPtr clock_entity_;\n GraphEntityPtr connect_entity_;\n GraphEntityPtr network_ctx_;\n gxf_context_t context_ = kNullContext;\n std::string name_;\n bool is_setup_{false};\n};\n\ntypedef std::shared_ptr SegmentPtr;\n\nstruct SegmentConnection {\n SegmentConnection(SegmentPtr source, SegmentPtr target, std::vector port_maps)\n : source(source), target(target), port_maps(port_maps) {}\n SegmentPtr source;\n SegmentPtr target;\n std::vector port_maps;\n\n bool operator==(const SegmentConnection& other) const {\n if (source != other.source || target != other.target) {\n return false;\n }\n if (port_maps.size() != other.port_maps.size()) {\n return false;\n }\n for (size_t i = 0; i < port_maps.size(); i++) {\n if (!(port_maps.at(i) == other.port_maps.at(i))) {\n return false;\n }\n }\n return true;\n }\n\n struct Hash {\n std::size_t operator()(const SegmentConnection& sc) const {\n std::size_t h1 = std::hash{}(sc.source);\n std::size_t h2 = std::hash{}(sc.target);\n std::size_t h3 = std::hash{}(sc.port_maps.size());\n return h1 ^ h2 ^ h3;\n }\n };\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SEGMENT_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/app/worker.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_APPLICATION_WORKER_HPP_\n#define NVIDIA_GXF_APPLICATION_WORKER_HPP_\n\n#include \n#include \n#include \n\n#include \"gxf/app/segment.hpp\"\n#include \"gxf/std/graph_worker.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nclass Application;\n\n/**\n * @brief GraphWorker representation in Application API layer\n * It manages the execution of selected segments\n *\n */\nclass Worker {\n public:\n Worker(Application* owner, const std::string& name);\n\n std::string name() { return name_; }\n Expected setPort(uint32_t port) { port_ = port; return Success; }\n Expected setDriverIp(const std::string& ip) { driver_ip_ = ip; return Success; }\n Expected setDriverPort(uint32_t port) { driver_port_ = port; return Success; }\n // set selected segments to run\n Expected setSegments(const std::unordered_set& segment_names) {\n segment_names_ = segment_names;\n return Success;\n }\n // commit the setup into GraphWorker\n Expected commit();\n\n private:\n Application* owner_;\n std::string name_;\n GraphEntityPtr worker_entity_;\n // core component\n Handle graph_worker_;\n // server interface object\n Handle server_;\n // client interface object\n Handle client_;\n\n // worker server's own port\n uint32_t port_ = 0;\n // target driver server's IP address\n std::string driver_ip_;\n // target driver server's port\n uint32_t driver_port_ = 0;\n // selected segments to run by this worker\n std::unordered_set segment_names_;\n};\ntypedef std::shared_ptr WorkerPtr;\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_APPLICATION_WORKER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/constant_behavior.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_BT_CONSTANT_BEHAVIOR_HPP_\n#define NVIDIA_GXF_BT_CONSTANT_BEHAVIOR_HPP_\n\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/controller.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Constant Behavior Codelet switches its own status to the configured desired\n// ||constant_status| after each tick.\nclass ConstantBehavior : public Codelet {\n public:\n virtual ~ConstantBehavior() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t tick() override;\n\n private:\n // the desired status to switch to during each tick\n Parameter constant_status_;\n enum ConstantBehaviorType {\n CONSTANT_SUCCESS = 0,\n CONSTANT_FAILURE = 1,\n };\n\n // its own scheduling term to start/stop itself\n Parameter> s_term_;\n\n SchedulingConditionType ready_conditions;\n SchedulingConditionType never_conditions;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_BT_CONSTANT_BEHAVIOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/entity_count_failure_repeat_controller.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_BT_ENTITY_COUNT_FAILURE_REPEAT_CONTROLLER_HPP_\n#define NVIDIA_GXF_BT_ENTITY_COUNT_FAILURE_REPEAT_CONTROLLER_HPP_\n\n#include \"gxf/core/parameter_parser_std.hpp\"\n#include \"gxf/std/controller.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Repeat the entity on failure up to |max_repeat_count_| times, then deactivate\n// the entity\nclass EntityCountFailureRepeatController : public Controller {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_controller_status_t control(gxf_uid_t eid, Expected code) override;\n\n private:\n size_t repeat_count_;\n Parameter max_repeat_count_;\n gxf_controller_status_t controller_status;\n // Take gxf_result_t codelet::tick() to entity_state_t\n // controller_status.behavior_status\n entity_state_t setBehaviorStatus(gxf_result_t tick_result);\n // Set execution status based on behavior status and repeat counter\n gxf_execution_status_t setExecStatus(entity_state_t& behavior_status);\n // if code = EntityItem::execute() returns FAILURE & exec_status !=\n // GXF_EXECUTE_FAILURE set behavior status to GXF_BEHAVIOR_RUNNING so that\n // parent codelet knows it's running\n Parameter return_behavior_running_if_failure_repeat_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_BT_ENTITY_COUNT_FAILURE_REPEAT_CONTROLLER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/parallel_behavior.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_BT_PARALLEL_BEHAVIOR_HPP_\n#define NVIDIA_GXF_BT_PARALLEL_BEHAVIOR_HPP_\n\n#include \n\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/controller.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Runs its child entities in parallel. By default, succeeds when all child\n// entities succeed and fails when all child entities fail.\nclass ParallelBehavior : public Codelet {\n public:\n virtual ~ParallelBehavior() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t tick() override;\n\n private:\n // parent codelet points to children's scheduling terms to schedule child\n // entities\n Parameter > > children_;\n std::vector > children;\n std::vector children_eid;\n // its own scheduling term to start/stop itself\n Parameter > s_term_;\n Handle s_term;\n size_t getNumChildren() const;\n entity_state_t GetChildStatus(size_t child_id);\n gxf_result_t startChild(size_t child_id);\n gxf_result_t stopAllChild();\n Parameter success_threshold_;\n Parameter failure_threshold_;\n SchedulingConditionType ready_conditions;\n SchedulingConditionType never_conditions;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_BT_PARALLEL_BEHAVIOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/repeat_behavior.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_BT_REPEAT_BEHAVIOR_HPP_\n#define NVIDIA_GXF_BT_REPEAT_BEHAVIOR_HPP_\n\n#include \n\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/controller.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Repeat Behavior\n// Repeats its only child entity. By default, won’t repeat when the child entity\n// fails. This can be customized using parameters.\nclass RepeatBehavior : public Codelet {\n public:\n virtual ~RepeatBehavior() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t tick() override;\n\n private:\n // parent codelet points to children's scheduling terms to schedule child\n // entities\n Parameter > > children_;\n std::vector > children;\n std::vector children_eid;\n // its own scheduling term to start/stop itself\n Parameter > s_term_;\n Handle s_term;\n Parameter repeat_after_failure_;\n size_t getNumChildren() const;\n entity_state_t GetChildStatus(size_t child_id);\n gxf_result_t startChild(size_t child_id);\n SchedulingConditionType ready_conditions;\n SchedulingConditionType never_conditions;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_BT_REPEAT_BEHAVIOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/selector_behavior.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_BT_SELECTOR_BEHAVIOR_HPP_\n#define NVIDIA_GXF_BT_SELECTOR_BEHAVIOR_HPP_\n\n#include \n\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/controller.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Selector Behavior\n// Runs all child entities in sequence until one succeeds, then reports success.\n// If all child entities fail (or no child entities are present), this codelet\n// fails.\nclass SelectorBehavior : public Codelet {\n public:\n virtual ~SelectorBehavior() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t tick() override;\n\n private:\n // parent codelet points to children's scheduling terms to schedule child\n // entities\n Parameter > > children_;\n std::vector > children;\n std::vector children_eid;\n // its own scheduling term to start/stop itself\n Parameter > s_term_;\n Handle s_term;\n size_t getNumChildren() const;\n entity_state_t GetChildStatus(size_t child_id);\n gxf_result_t startChild(size_t child_id);\n size_t current_child_id;\n SchedulingConditionType ready_conditions;\n SchedulingConditionType never_conditions;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_BT_SELECTOR_BEHAVIOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/sequence_behavior.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_BT_SEQUENCE_BEHAVIOR_HPP_\n#define NVIDIA_GXF_BT_SEQUENCE_BEHAVIOR_HPP_\n\n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/controller.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Sequence Behavior\n// Runs its child entities in sequence, in the order in which they are defined.\n// Succeeds when all child entities succeed, or fails as soon as one child\n// entity fails.\nclass SequenceBehavior : public Codelet {\n public:\n virtual ~SequenceBehavior() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t tick() override;\n\n private:\n // parent codelet points to children's scheduling terms to schedule child\n // entities\n Parameter, kMaxComponents> >\n children_;\n FixedVector, kMaxComponents> children;\n std::vector children_eid;\n // its own scheduling term to start/stop itself\n Parameter > s_term_;\n Handle s_term;\n size_t getNumChildren() const;\n entity_state_t GetChildStatus(size_t child_id);\n gxf_result_t startChild(size_t child_id);\n size_t current_child_id;\n SchedulingConditionType ready_conditions;\n SchedulingConditionType never_conditions;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_BT_SEQUENCE_BEHAVIOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/switch_behavior.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_BT_SWITCH_BEHAVIOR_HPP_\n#define NVIDIA_GXF_BT_SWITCH_BEHAVIOR_HPP_\n\n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/controller.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Switch Behavior\n// Runs the child entity with the index defined as desired_behavior.\nclass SwitchBehavior : public Codelet {\n public:\n virtual ~SwitchBehavior() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t tick() override;\n\n private:\n // parent codelet points to children's scheduling terms to schedule child\n // entities\n // Parameter > > children_;\n // std::vector > children;\n Parameter, kMaxComponents> >\n children_;\n FixedVector, kMaxComponents> children;\n std::vector children_eid;\n // its own scheduling term to start/stop itself\n Parameter > s_term_;\n Handle s_term;\n\n // the child entity to switch to. this child entity will run when this parent\n // entity runs and the parent entity will return this child entity's behavior\n // status may not be empty\n Parameter desired_behavior_;\n size_t getNumChildren() const;\n entity_state_t GetChildStatus(size_t child_id);\n gxf_result_t startChild(size_t child_id);\n size_t current_child_id;\n SchedulingConditionType ready_conditions;\n SchedulingConditionType never_conditions;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_BT_SWITCH_BEHAVIOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/timer_behavior.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_BT_TIMER_BEHAVIOR_HPP_\n#define NVIDIA_GXF_BT_TIMER_BEHAVIOR_HPP_\n\n#include \"gxf/std/clock.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/controller.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Timer Behavior\n// Waits for a specified amount of time delay,\n// and switches to the configured result switch_status afterwards.\nclass TimerBehavior : public Codelet {\n public:\n virtual ~TimerBehavior() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t tick() override;\n\n private:\n // a specified time (in seconds) after which the status of this node will be\n // changed\n Parameter delay_;\n\n // the desired status to switch to when the tick time is delay_ seconds after\n // first tick Setting this value to “running” will lead to undefined behavior\n // in the application.\n Parameter switch_status_;\n enum SwitchStatus {\n kSwitchToSuccess = 0,\n kSwitchToFailure = 1,\n kSwitchToRunning = 2,\n };\n\n // Use this clock to get wait time since first tick\n Parameter> clock_;\n\n // its own scheduling term to start/stop itself\n Parameter> s_term_;\n\n bool is_first_tick_ = true;\n\n // timestamp of the last tick which caused a status switch\n int64_t last_switch_timestamp_ = 0;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_BT_TIMER_BEHAVIOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/common_expected_macro.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \"common/expected.hpp\"\n\n// Concatenates its two arguments.\n#define EXPECTED_MACRO_INTERNAL_CONCAT(a, b) EXPECTED_MACRO_INTERNAL_CONCAT_IMPL(a, b)\n#define EXPECTED_MACRO_INTERNAL_CONCAT_IMPL(a, b) a##b\n\n// Converts its argument to a string at compile time.\n#define EXPECTED_MACRO_INTERNAL_TO_STRING(x) EXPECTED_MACRO_INTERNAL_TO_STRING_IMPL(x)\n#define EXPECTED_MACRO_INTERNAL_TO_STRING_IMPL(x) #x\n\n// Gets the current location in the source code in the format \"file:line\".\n#define EXPECTED_MACRO_INTERNAL_FILE_LINE() __FILE__ \":\" EXPECTED_MACRO_INTERNAL_TO_STRING(__LINE__)\n\n// Helper to support logging a default message and an optional custom message.\n#define EXPECTED_MACRO_INTERNAL_LOG_IN_EXPECT_MACRO(expression_result, expression_string, ...) \\\n nvidia::expected_macro::LogHelper(__FILE__, __LINE__, expression_result, expression_string, \\\n ##__VA_ARGS__);\n\n// Helper to check the return type of the expression used in RETURN_IF_ERROR.\n#define EXPECTED_MACRO_INTERNAL_CHECK_EXPRESSION_IS_RESULT(expression_result) \\\n static_assert( \\\n nvidia::expected_macro::IsStatus::value || \\\n nvidia::expected_macro::IsUnwrappable::value , \\\n EXPECTED_MACRO_INTERNAL_FILE_LINE() \\\n \": RETURN_IF_ERROR can only be used with expressions that return a result type. You \" \\\n \"can register a type as a result type unwrappable with one of\" \\\n \"`template <> struct IsUnwrappable : std::true_type {};` or \" \\\n \"`template <> struct IsStatus : std::true_type {}`. \");\n\n// Helper to check the return type of the expression used in UNWRAP_OR_RETURN.\n#define EXPECTED_MACRO_INTERNAL_CHECK_EXPRESSION_IS_UNWRAPPABLE(expression_result) \\\n static_assert( \\\n nvidia::expected_macro::IsUnwrappable::value, \\\n EXPECTED_MACRO_INTERNAL_FILE_LINE() \\\n \": UNWRAP_OR_RETURN can only be used with expressions that return an unwrappable type. \" \\\n \"You can register a type as being unwrappable with \" \\\n \"`template <> struct IsUnwrappable : std::true_type {};`. For expressions \" \\\n \"returning a status instead of an unwrappable use `RETURN_IF_ERROR` instead.\");\n\n// Evaluates an expression that returns a result type. If the returned result contains an error it\n// returns the error. This macro can only be used in functions that also return a result type.\n//\n// Per default the macro already creates an error message that includes the evaluated expression. If\n// needed an optional string can be passed that will be appended to the default error message. It is\n// also possible to use format specifiers to customize the string.\n//\n// It is also possible to pass the Severity used for logging as an additional argument. This is\n// required if using a custom error message.\n//\n// Example:\n// Expected DoSomething();\n// Expected DoAnotherThing();\n//\n// Expected foo(){\n// RETURN_IF_ERROR(DoSomething());\n// RETURN_IF_ERROR(DoAnotherThing(), Severity::WARNING);\n// RETURN_IF_ERROR(DoAnotherThing(), Severity::WARNING, \"Custom error message.\");\n// }\n#define RETURN_IF_ERROR(expression, ...) \\\n ({ \\\n auto maybe_result = (expression); \\\n EXPECTED_MACRO_INTERNAL_CHECK_EXPRESSION_IS_RESULT(maybe_result) \\\n if (!nvidia::expected_macro::IsValid(maybe_result)) { \\\n EXPECTED_MACRO_INTERNAL_LOG_IN_EXPECT_MACRO(maybe_result, #expression, ##__VA_ARGS__) \\\n return nvidia::expected_macro::ProxyFactory::FromStatusOrUnwrappable(maybe_result); \\\n } \\\n })\n\n// Evaluates an expression that returns a type that can be casted to a boolean. If the expression is\n// false it returns an error. This macro can only be used in functions returning a result type.\n//\n// The difference to RETURN_IF_ERROR is that this macro will always cast the expression to a\n// boolean. Thus if your expression returns a status that can be more than just true/false you will\n// loose the additional information. In those cases RETURN_IF_ERROR is preferred. Use this macro\n// only to check preconditions like a < b, or c != nullptr.\n//\n// Per default the macro already creates an error message that includes the evaluated expression. If\n// needed an optional string can be passed that will be appended to the default error message. It is\n// also possible to use format specifiers to customize the string.\n//\n// It is also possible to pass the Severity used for logging as an additional argument. This is\n// required if using a custom error message.\n//\n// Example:\n// Expected foo(){\n// RETURN_IF_FALSE(1 > 2);\n// RETURN_IF_FALSE(1 > 2, Severity::WARNING);\n// RETURN_IF_FALSE(1 > 2, Severity::WARNING, \"1 is not bigger than 2\");\n// }\n#define RETURN_IF_FALSE(expression, ...) \\\n do { \\\n const bool result = static_cast(expression); \\\n if (!result) { \\\n EXPECTED_MACRO_INTERNAL_LOG_IN_EXPECT_MACRO(result, #expression, ##__VA_ARGS__) \\\n return nvidia::expected_macro::ProxyFactory::FromStatusOrUnwrappable(result); \\\n } \\\n } while (0)\n\n// Evaluates an expression that returns an unwrappable type. If the returned type contains an error\n// it returns the error, else it unwraps the value. This macro can only be used in functions\n// returning a result type.\n//\n// Per default the macro already creates an error message that includes the evaluated expression. If\n// needed an optional string can be passed that will be appended to the default error message. It is\n// also possible to use format specifiers to customize the string.\n//\n// It is also possible to pass the Severity used for logging as an additional argument.\n//\n// Note that this macro uses expression-statements (i.e. the ({ }) surrounding the macro) which are\n// a non-standard functionality. However they are present in almost all compilers. We currently only\n// know of MSVC that does not support this.\n//\n// Example:\n// Expected GetString();\n// Expected GetAnotherString();\n//\n// Expected CountCombinedStringLength(){\n// const std::string str1 = UNWRAP_OR_RETURN(GetString());\n// std::string str2;\n// str2 = UNWRAP_OR_RETURN(GetAnotherString(), \"This should not fail. Str1 has value %s.\",\n// str1.c_str());\n// const std::string str3 = UNWRAP_OR_RETURN(GetAnotherString(), Severity::WARNING);\n// const std::string str4 = UNWRAP_OR_RETURN(GetAnotherString(), Severity::WARNING,\n// \"Custom error message\");\n// return str1.size() + str2.size() + str3.size() + str4.size();\n// }\n#define UNWRAP_OR_RETURN(expression, ...) \\\n ({ \\\n auto maybe_result = (expression); \\\n EXPECTED_MACRO_INTERNAL_CHECK_EXPRESSION_IS_UNWRAPPABLE(maybe_result) \\\n if (!nvidia::expected_macro::IsValid(maybe_result)) { \\\n EXPECTED_MACRO_INTERNAL_LOG_IN_EXPECT_MACRO(maybe_result, #expression, ##__VA_ARGS__) \\\n return nvidia::expected_macro::ProxyFactory::FromUnwrappable(maybe_result); \\\n } \\\n std::move(maybe_result.value()); \\\n })\n\n// All functions in the following namespace have to be specialized for a given result type in order\n// to enable the macro for the type.\nnamespace nvidia::expected_macro {\n\n// Type trait to check if a type can be used as a status.\ntemplate \nstruct IsStatus : std::false_type {};\n\n// Type trait to check if a type can be used as an unwrappable.\ntemplate \nstruct IsUnwrappable : std::false_type {};\n\n// The value that represents the default error for a given status type.\ntemplate \nconstexpr Status DefaultError();\n\n// Check if a result types is valid.\ntemplate \nconstexpr bool IsValid(const Result& result) {\n return static_cast(result);\n}\n\n// Helper struct to get the status type of a result. This is needed for the StatusValue helper below\n// to automatically infer the return type.\n//\n// Per default we use the same type as the\n// result, which holds for all status types. Thus this only has to be specialized for unwrappable\n// types.\ntemplate \nstruct StatusType {\n using Type = Result;\n};\n\n// Helper function to get the status of a result. We have to use a static member function instead of\n// a free function because we want the possibility for a user to only provide a partial template\n// specialization of this.\ntemplate \nstruct StatusValue {\n static constexpr typename StatusType::Type Get(const Result& result) { return result; }\n};\n\n// Get the name corresponding to a status, s.t. it can be printed.\ntemplate \nstruct StatusName {\n static std::string Get(Status status);\n};\n\n// Get the invalid unwrappable corresponding to an unwrappable. Eg. std::nullopt for std::optional.\ntemplate \nstruct InvalidUnwrappable {\n static Unwrappable Get(Status status);\n};\n\nconstexpr Severity kDefaultSeverity = Severity::ERROR;\n\ntemplate \nconstexpr typename StatusType::Type GetStatus(const Result& result) {\n return StatusValue::Get(result);\n}\n\ntemplate \nstd::string GetStatusName(Status status) {\n return StatusName::Get(status);\n}\n\ntemplate \nUnwrappable GetInvalidUnwrappable(Status status) {\n return InvalidUnwrappable::Get(status);\n}\n\n// ProxyFactory to create an ResultProxy. We create a separate class for these functions\n// because ResultProxy is templated and thus could not be used without explicitly\n// specifying the template.\n\ntemplate \nclass ResultProxy;\n\n// ProxyFactory to create an ResultProxy. We create a separate class for these functions\n// because ResultProxy is templated and thus could not be used without explicitly\n// specifying the template.\nclass ProxyFactory {\n public:\n // Constructs the proxy from an unwrappable type. The unwrappable has to be in an error state. We\n // do not check this because the macro should have already done this check. We use static\n // methods instead of constructors to explicitly disallow construction from certain types in\n // different situations.\n template <\n typename Unwrappable, typename = std::enable_if_t::value>>\n static ResultProxy::Type> FromUnwrappable(\n const Unwrappable& unwrappable) {\n return ResultProxy(GetStatus(unwrappable));\n }\n\n // Constructs the proxy from a status type. The status has to be in an error state. We do not\n // check this because the macro should have already done this check. We use static methods instead\n // of constructors to explicitly disallow construction from certain types in different situations.\n template \n static ResultProxy::Type> FromStatusOrUnwrappable(\n const Result& result) {\n return ResultProxy(GetStatus(result));\n }\n};\n\n// A proxy class to allow implicit casting of one result type to another result type. Thus in a\n// function that returns a result type one can simply return this proxy and then it will implicitly\n// cast to the appropriate return type.\ntemplate \nclass ResultProxy {\n public:\n // Casts the proxy to a status or unwrappable type. Note that this cast is not allowed to be\n // explicit.\n template <\n typename T,\n typename = std::enable_if_t::value || IsUnwrappable::value>>\n constexpr operator T() const {\n if constexpr (IsStatus::value) {\n return castToStatus();\n } else {\n return castToInvalidUnwrappable();\n }\n }\n\n private:\n // Constructs the proxy from a status type. The status has to be in an error state.\n // We do not check for this because we rely on the macro already having done that check.\n constexpr explicit ResultProxy(Status error) : error_(error) {}\n\n // Casts the proxy to a status type. If the error type is not equal to the proxy's error type,\n // a default error is used.\n template \n constexpr OtherStatus castToStatus() const {\n static_assert(IsStatus::value, \"OtherStatus has to be a status type.\");\n if constexpr (std::is_same_v) {\n return error_;\n } else {\n return DefaultError();\n }\n }\n\n // Casts the proxy to an invalid unwrappable type (eg. std::nullopt or nvidia::Unexpected).\n template \n constexpr Unwrappable castToInvalidUnwrappable() const {\n static_assert(\n IsUnwrappable::value, \"Unwrappable has to be a status type.\");\n using OtherStatus = typename StatusType::Type;\n return GetInvalidUnwrappable(castToStatus());\n }\n\n Status error_;\n // TODO(tazhang): enable the following.\n // static_assert(IsStatus::value, \"Status has to be a status type.\");\n\n friend ProxyFactory;\n};\n\n// Helper function for the logging in the above macros. This version should be used when the user\n// also specifies the logging severity. The variadic arguments can be used to do string\n// interpolation in the custom_text variable.\ntemplate \nvoid LogHelper(const char* file, int line, const ExpressionResult& expression_result,\n const std::string& expression_string, Severity severity,\n const std::string& custom_txt = \"\", Args... args) {\n const auto error = GetStatus(expression_result);\n const std::string text = \"Expression '\" + expression_string + \"' failed with error '\" +\n GetStatusName(error) + \"'. \" + custom_txt;\n\n // GCC is not able to do format security validation when the string is coming from a variadic\n // template, even if the string is originally a char* ignore this warning until a more recent GCC\n // version fixes this behavior.\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wformat-security\"\n ::nvidia::Log(file, line, severity, text.c_str(), args...);\n#pragma GCC diagnostic pop\n}\n\n// Overload of the LogHelper above. This version does not take the severity as an argument and used\n// the default severity instead.\ntemplate \nvoid LogHelper(const char* file, int line, const ExpressionResult& expression_result,\n const std::string& expression_string, const std::string& custom_text = \"\",\n Args... args) {\n LogHelper(file, line, expression_result, expression_string, kDefaultSeverity, custom_text,\n args...);\n}\n\n} // namespace nvidia::expected_macro\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/component.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_COMPONENT_HPP\n#define NVIDIA_GXF_CORE_COMPONENT_HPP\n\n#include \n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/core/parameter.hpp\"\n#include \"gxf/core/parameter_storage.hpp\"\n#include \"gxf/core/registrar.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Components are parts of an entity and provide their functionality. The Component class is the\n// base class of all GXF components.\nclass Component {\n public:\n virtual ~Component() = default;\n\n Component(const Component& component) = delete;\n Component(Component&& component) = delete;\n Component& operator=(const Component& component) = delete;\n Component& operator=(Component&& component) = delete;\n\n // Used to register all parameters of the components. Do not use this function for other purposes\n // as it might be called at anytime by the runtime.\n //\n // Example:\n // class Foo : public Component {\n // public:\n // gxf_result_t registerInterface(Registrar* registrar) override {\n // registrar->parameter(count_, \"count\", 1);\n // }\n // Parameter count_;\n // };\n virtual gxf_result_t registerInterface(Registrar* registrar) {\n registrar_ = registrar;\n parameter_storage_ = registrar_->getParameterStorage();\n registrar->registerParameterlessComponent();\n return GXF_SUCCESS;\n }\n\n // Use to start the lifetime of a component and should be used instead of the constructor.\n // Called after all components of an entity are created. The order in which components within\n // the same entity are initialized is undefined.\n virtual gxf_result_t initialize() { return GXF_SUCCESS; }\n\n // Use to end the lifetime of a component and should be used instead of the deconstructor.\n // The order in which components within the same entity are deinitialized is undefined.\n virtual gxf_result_t deinitialize() { return GXF_SUCCESS; }\n\n gxf_context_t context() const noexcept { return context_; }\n gxf_uid_t eid() const noexcept { return eid_; }\n gxf_uid_t cid() const noexcept { return cid_; }\n gxf_tid_t tid() const noexcept { return tid_; }\n const char* type_name() const noexcept { return typename_; }\n\n // The entity which owns this component\n Entity entity() const noexcept {\n // FIXME(v1) check that value exists\n return Entity::Shared(context(), eid()).value();\n }\n\n // Gets the name of the component\n const char* name() const noexcept {\n const char* result;\n const gxf_result_t code = GxfComponentName(context(), cid(), &result);\n return (code == GXF_SUCCESS) ? result : \"\";\n }\n\n // This function shall only be called by GXF and is used to setup the component.\n void internalSetup(gxf_context_t context, gxf_uid_t eid, gxf_uid_t cid, Registrar* registrar) {\n context_ = context;\n eid_ = eid;\n cid_ = cid;\n GxfComponentType(context_, cid_, &tid_);\n GxfComponentTypeName(context_, tid_, &typename_);\n if (registrar) {\n registrar_ = registrar;\n parameter_storage_ = registrar_->getParameterStorage();\n parameter_registrar_ = registrar_->getParameterRegistrar();\n }\n }\n\n // query value of component parameter \"key\"\n template\n Expected getParameter(const char* key) {\n return parameter_storage_->get(cid_, key);\n }\n\n // set the parameter \"key\" and of type T with value\n template \n Expected setParameter(const char* key, T value) {\n if (!parameter_storage_) { return Unexpected{GXF_ARGUMENT_NULL}; }\n return parameter_storage_->set(cid_, key, std::move(value));\n }\n\n // set a parameter \"key\" of handle type with value\n template \n Expected setParameter(const char* key, Handle& value) {\n if (!parameter_storage_) { return Unexpected{GXF_ARGUMENT_NULL}; }\n return parameter_storage_->setHandle(cid_, key, value->cid());\n }\n\n // set the parameter \"key\" with the value in yaml node\n Expected parseParameter(const char* key, const YAML::Node& node, std::string prefix = \"\") {\n return parameter_storage_->parse(cid_, key, node, prefix);\n }\n\n // wrap the current value of the parameter \"key\" in a yaml node\n Expected wrapParameter(const char* key) {\n return parameter_storage_->wrap(cid_, key);\n }\n\n // query all parameters in the component of type T and return their ComponentParameterInfo struct\n template\n Expected> getParametersOfType() {\n gxf_tid_t tid = GxfTidNull();\n auto result = GxfComponentType(context_, cid_, &tid);\n if (!isSuccessful(result)) {\n GXF_LOG_ERROR(\"Failed to find component type for cid [%ld]\", cid_);\n return Unexpected{result};\n }\n\n return parameter_registrar_->getParametersOfType(tid);\n }\n\n // query componentParameterInfo of parameter \"key\"\n Expected getParameterInfo(const char* key) {\n gxf_tid_t tid = GxfTidNull();\n auto result = GxfComponentType(context_, cid_, &tid);\n if (!isSuccessful(result)) {\n GXF_LOG_ERROR(\"Failed to find component type for cid [%ld]\", cid_);\n return Unexpected{result};\n }\n\n ParameterRegistrar::ComponentParameterInfo info =\n *(GXF_UNWRAP_OR_RETURN(parameter_registrar_->getComponentParameterInfoPtr(tid, key)));\n return info;\n }\n\n protected:\n Component() = default;\n\n gxf_context_t context_ = kNullContext;\n gxf_uid_t eid_ = kNullUid;\n gxf_uid_t cid_ = kNullUid;\n gxf_tid_t tid_ = GxfTidNull();\n const char* typename_ = \"UNKNOWN\";\n Registrar* registrar_ = nullptr;\n ParameterRegistrar* parameter_registrar_ = nullptr;\n ParameterStorage* parameter_storage_ = nullptr;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/entity.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_ENTITY_HPP_\n#define NVIDIA_GXF_CORE_ENTITY_HPP_\n\n#include \n\n#include \"common/assert.hpp\"\n#include \"common/fixed_vector.hpp\"\n#include \"common/type_name.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/expected_macro.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/core/handle.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief All GXF objects are entities. An entity owns multiple components which define the functionality\n * of the entity. Entities themselves are nothing more than a unique identifier. Entities created using the\n * C++ type is ref counted. The ref count is automatically decreased when the entity object is destructed or\n * goes out of scope.\n *\n */\nclass Entity {\n public:\n /**\n * @brief Creates a new entity using the given context and optionally set the given name. The\n * caller of this api own's the object. The reference count is set to 1 and it is automatically\n * reduced when this object is destroyed or goes out of scope.\n *\n * @param context A valid GXF context\n * @param name Name for the entity object to be created\n * @return Expected Entity object wrapped in an expected type to capture error on failure\n */\n static Expected New(gxf_context_t context, const char* name = nullptr) {\n gxf_uid_t eid;\n const GxfEntityCreateInfo info = {0};\n void* item_ptr = nullptr;\n gxf_result_t code = GxfCreateEntityAndGetItem(context, &info, &eid, &item_ptr);\n if (code != GXF_SUCCESS) { return Unexpected{code}; }\n\n return Shared(context, eid, item_ptr);\n }\n\n /**\n * @brief Creates an entity handle based on an existing ID and takes ownership.\n * Reference count is not increased.\n *\n * @param context A valid GXF context\n * @param eid The unique object ID (UID) of a valid entity\n * @param item_ptr An optional entity item pointer\n * @return Expected Entity object wrapped in an expected type to capture error on failure\n */\n static Expected Own(gxf_context_t context, gxf_uid_t eid, void* item_ptr = nullptr) {\n Entity result;\n result.context_ = context;\n result.eid_ = eid;\n result.entity_item_ptr_ = item_ptr;\n return result;\n }\n\n /**\n * @brief Creates an entity handle based on an existing ID and shares ownership.\n * Reference count is increased by one.\n *\n * @param context A valid GXF context\n * @param eid The unique object ID (UID) of a valid entity\n * @param item_ptr An optional entity item pointer\n * @return Expected Entity object wrapped in an expected type to capture error on failure\n */\n static Expected Shared(gxf_context_t context, gxf_uid_t eid, void* ptr = nullptr) {\n Entity result;\n result.context_ = context;\n result.eid_ = eid;\n result.entity_item_ptr_ = ptr;\n const gxf_result_t code = GxfEntityRefCountInc(context, eid);\n if (code != GXF_SUCCESS) {\n return Unexpected{code};\n } else {\n return result;\n }\n }\n\n /**\n * @brief Construct a new entity object using default constructor.\n * This is a null entity without a valid context of entity ID.\n *\n */\n Entity() = default;\n\n /**\n * @brief Construct a new entity object by copying from another entity object.\n *\n * @param other A valid Entity object\n */\n Entity(const Entity& other) {\n eid_ = other.eid();\n context_ = other.context();\n entity_item_ptr_ = other.entity_item_ptr();\n if (eid_ != kNullUid) {\n // FIXME(dweikersdorf) How do we deal with failure?\n GxfEntityRefCountInc(context_, eid_);\n }\n }\n\n /**\n * @brief Construct a new entity object by moving the contents from an existing entity object.\n *\n * @param other A valid Entity object\n */\n Entity(Entity&& other) {\n context_ = other.context_;\n eid_ = other.eid_;\n entity_item_ptr_ = other.entity_item_ptr_;\n other.context_ = kNullContext;\n other.eid_ = kNullUid;\n other.entity_item_ptr_ = kNullUid;\n }\n\n /**\n * @brief Operator overload for copy assignment operation\n *\n * @param other A valid Entity object\n * @return Entity& The resulting copied entity object\n */\n Entity& operator=(const Entity& other) {\n // In case other point to the same entity, nothing needs to be done.\n if (eid_ == other.eid() && context_ == other.context()) {\n return *this;\n }\n if (eid_ != kNullUid) {\n release();\n }\n context_ = other.context();\n eid_ = other.eid();\n entity_item_ptr_ = other.entity_item_ptr();\n if (eid_ != kNullUid) {\n // FIXME(dweikersdorf) How do we deal with failure?\n GxfEntityRefCountInc(context_, eid_);\n }\n return *this;\n }\n\n /**\n * @brief Operator overload for move assignment operation\n *\n * @param other A valid Entity object\n * @return Entity& The resulting moved entity object\n */\n Entity& operator=(Entity&& other) {\n // In case other is this, then nothing should be done.\n if (&other == this) {\n return *this;\n }\n if (eid_ != kNullUid) {\n release();\n }\n context_ = other.context_;\n eid_ = other.eid_;\n entity_item_ptr_ = other.entity_item_ptr_;\n other.entity_item_ptr_ = nullptr;\n other.context_ = kNullContext;\n other.eid_ = kNullUid;\n return *this;\n }\n\n /**\n * @brief Destroy the Entity object. Reduces the reference count by 1.\n *\n */\n ~Entity() {\n if (eid_ != kNullUid) {\n release();\n }\n }\n\n /**\n * @brief Activates the entity. See GxfEntityActivate in gxf.h\n *\n * @return Expected\n */\n Expected activate() {\n return ExpectedOrCode(GxfEntityActivate(context(), eid()));\n }\n\n /**\n * @brief Deactivates the entity. See GxfEntityDectivate in gxf.h\n *\n * @return Expected\n */\n Expected deactivate() {\n return ExpectedOrCode(GxfEntityDeactivate(context(), eid()));\n }\n\n /**\n * @brief Clone an entity from an existing entity object. The returned entity shares the\n * ownership with the entity being cloned from. Reference count is increased by one.\n *\n * @return Expected\n */\n Expected clone() const {\n return Shared(context(), eid(), entity_item_ptr());\n }\n\n /**\n * @brief Returns the GXF context of the entity.\n *\n * @return gxf_context_t\n */\n gxf_context_t context() const { return context_; }\n\n /**\n * @brief Returns the unique object ID (UID) of the entity\n *\n * @return gxf_uid_t\n */\n gxf_uid_t eid() const { return eid_; }\n\n /**\n * @brief Checks if an entity object is null (empty) or not\n *\n * @return true If entity is not null (empty) entity object\n * @return false If the entity is a valid object\n */\n bool is_null() const { return eid_ == kNullUid; }\n\n /**\n * @brief The name of the entity or empty string if no name has been given to the entity.\n *\n * @return const char* pointer to name of the entity\n */\n const char* name() const {\n const char* ptr;\n const gxf_result_t result = GxfEntityGetName(context_, eid_, &ptr);\n return (result == GXF_SUCCESS) ? ptr : \"\";\n }\n\n /**\n * @brief Adds a component with given type ID.\n *\n * @param tid A valid type ID of a registered component\n * @param name Name to be given to the newly created component instance\n * @return Expected An untyped handle to component or error on failure\n */\n Expected add(gxf_tid_t tid, const char* name = nullptr) {\n gxf_uid_t cid;\n void* comp_ptr = nullptr;\n GXF_RETURN_IF_ERROR(check_entity_item_ptr());\n const auto result = GxfComponentAddAndGetPtr(context(), entity_item_ptr(), tid,\n name, &cid, &comp_ptr);\n if (result != GXF_SUCCESS) {\n return Unexpected{result};\n }\n return UntypedHandle::Create(context(), cid, tid, comp_ptr);\n }\n\n /**\n * @brief Removes a component with given type ID.\n *\n * @param tid A valid type ID of a registered component\n * @param name Name to be given to the newly created component instance\n * @return Expected or error on failure\n */\n Expected remove(gxf_tid_t tid, const char* name = nullptr) {\n // TODO(pshekdar): Add new API GxfComponentRemoveCpp\n const auto result = GxfComponentRemove(context(), eid(), tid, name);\n return ExpectedOrCode(result);\n }\n\n /**\n * @brief Adds a component with given template component type\n *\n * @tparam T A valid template type of a registered component\n * @param name Name to be given to the newly created component instance\n * @return Expected> Typed Handle to the component instance\n */\n template \n Expected> add(const char* name = nullptr) {\n gxf_tid_t tid;\n const auto result_1 = GxfComponentTypeId(context(), TypenameAsString(), &tid);\n if (result_1 != GXF_SUCCESS) {\n return Unexpected{result_1};\n }\n gxf_uid_t cid;\n void* comp_ptr = nullptr;\n GXF_RETURN_IF_ERROR(check_entity_item_ptr());\n const auto result_2 = GxfComponentAddAndGetPtr(context(), entity_item_ptr(), tid, name, &cid,\n &comp_ptr);\n if (result_2 != GXF_SUCCESS) {\n return Unexpected{result_2};\n }\n return Handle::Create(context(), cid, tid, comp_ptr);\n }\n\n /**\n * @brief Removes a component with given template component type\n *\n * @tparam T A valid template type of a registered component\n * @param name Name of the component\n * @return Expected or error on failure\n */\n template \n Expected remove(const char* name = nullptr) {\n gxf_tid_t tid;\n // TODO(pshekdar): Add new API GxfComponentRemoveCpp\n const auto result_1 = GxfComponentTypeId(context(), TypenameAsString(), &tid);\n if (result_1 != GXF_SUCCESS) {\n return Unexpected{result_1};\n }\n const auto result_2 = GxfComponentRemove(context(), eid(), tid, name);\n return ExpectedOrCode(result_2);\n }\n\n /**\n * @brief Removes a component with given uid\n *\n * @tparam cid A valid uid of the component\n * @return Expected or error on failure\n */\n Expected remove(gxf_uid_t& cid) {\n const auto result = GxfComponentRemoveWithUID(context(), cid);\n return ExpectedOrCode(result);\n }\n\n /**\n * @brief Gets a component by type ID. Asserts if no such component.\n *\n * @param tid A valid type ID of a registered component\n * @param name Name of the component to lookup\n * @return Expected An untyped handle to component or error on failure\n */\n Expected get(gxf_tid_t tid, const char* name = nullptr) const {\n gxf_uid_t cid;\n void* comp_ptr = nullptr;\n GXF_RETURN_IF_ERROR(check_entity_item_ptr());\n const auto result = GxfComponentFindAndGetPtr(context(), eid(),\n static_cast(entity_item_ptr()),\n tid, name, nullptr, &cid, &comp_ptr);\n if (result != GXF_SUCCESS) {\n return Unexpected{result};\n }\n return UntypedHandle::Create(context(), cid, tid, comp_ptr);\n }\n\n /**\n * @brief Gets a component by type. Asserts if no such component.\n *\n * @tparam T A valid template type of a registered component\n * @param name Name of the component to lookup\n * @return Expected> Typed Handle to the component instance or error on failure\n */\n template \n Expected> get(const char* name = nullptr) const {\n gxf_tid_t tid;\n GXF_RETURN_IF_ERROR(check_entity_item_ptr());\n const auto result_1 = GxfComponentTypeId(context(), TypenameAsString(), &tid);\n if (result_1 != GXF_SUCCESS) {\n return Unexpected{result_1};\n }\n gxf_uid_t cid;\n void* comp_ptr = nullptr;\n const auto result_2 = GxfComponentFindAndGetPtr(context(), eid(),\n static_cast(entity_item_ptr()),\n tid, name, nullptr, &cid, &comp_ptr);\n if (result_2 != GXF_SUCCESS) {\n return Unexpected{result_2};\n }\n return Handle::Create(context(), cid, tid, comp_ptr);\n }\n\n /**\n * @brief Finds all components in an entity. A fixed-size vector of untyped handles of all the\n * components are returned.\n *\n * @tparam N Capacity of the FixedVector\n * @return Expected> A fixed-size vector of untyped handles of all\n * the components allocated on stack\n */\n template \n Expected> findAll() const {\n const gxf_context_t c_context = context();\n const gxf_uid_t c_eid = eid();\n gxf_uid_t cids[N];\n uint64_t num_cids = N;\n const gxf_result_t code = GxfComponentFindAll(c_context, c_eid, &num_cids, cids);\n if (code != GXF_SUCCESS) {\n return Unexpected{code};\n }\n /* coverity[stack_use_local_overflow] */\n FixedVector components;\n for (size_t i = 0; i < num_cids; i++) {\n const auto result = UntypedHandle::Create(c_context, cids[i])\n .map([&](UntypedHandle component) {\n return components.push_back(component)\n .substitute_error(GXF_EXCEEDING_PREALLOCATED_SIZE);\n });\n if (!result) {\n return ForwardError(result);\n }\n }\n return components;\n }\n\n /**\n * @brief Finds all components of given type.\n *\n * @tparam T A valid template type of a registered component\n * @tparam N Capacity of the FixedVector\n * @return Expected, N>> A fixed-size vector of typed handles of given\n * component type allocated on stack\n */\n template \n Expected, N>> findAll() const {\n const gxf_context_t c_context = context();\n const gxf_uid_t c_eid = eid();\n gxf_tid_t tid;\n const gxf_result_t code = GxfComponentTypeId(c_context, TypenameAsString(), &tid);\n if (code != GXF_SUCCESS) {\n return Unexpected{code};\n }\n /* coverity[stack_use_local_overflow] */\n FixedVector, N> components;\n for (int offset = 0; static_cast(offset) < N; offset++) {\n gxf_uid_t cid;\n const gxf_result_t code = GxfComponentFind(c_context, c_eid, tid, nullptr, &offset, &cid);\n if (code != GXF_SUCCESS) {\n break;\n }\n const auto result = Handle::Create(c_context, cid)\n .map([&](Handle component) {\n return components.push_back(component)\n .substitute_error(GXF_EXCEEDING_PREALLOCATED_SIZE);\n });\n if (!result) {\n return ForwardError(result);\n }\n }\n return components;\n }\n\n /**\n * @brief Finds all components in an entity. A fixed-size vector of untyped handles of all the\n * components are returned.\n *\n * @tparam N Capacity of the FixedVector\n * @return Expected> A fixed-size vector of untyped handles of all\n * the components allocated on heap\n */\n template \n Expected> findAllHeap() const {\n const gxf_context_t c_context = context();\n const gxf_uid_t c_eid = eid();\n gxf_uid_t cids[N];\n uint64_t num_cids = N;\n const gxf_result_t code = GxfComponentFindAll(c_context, c_eid, &num_cids, cids);\n if (code != GXF_SUCCESS) {\n return Unexpected{code};\n }\n FixedVector components;\n components.reserve(num_cids);\n for (size_t i = 0; i < num_cids; i++) {\n const auto result = UntypedHandle::Create(c_context, cids[i])\n .map([&](UntypedHandle component) {\n return components.push_back(component)\n .substitute_error(GXF_EXCEEDING_PREALLOCATED_SIZE);\n });\n if (!result) {\n return ForwardError(result);\n }\n }\n return components;\n }\n\n /**\n * @brief Finds all components of given type.\n *\n * @tparam T A valid template type of a registered component\n * @tparam N Capacity of the FixedVector\n * @return Expected>> A fixed-size vector of typed handles of given\n * component type allocated on heap\n */\n template \n Expected>> findAllHeap() const {\n const gxf_context_t c_context = context();\n const gxf_uid_t c_eid = eid();\n gxf_tid_t tid;\n const gxf_result_t code = GxfComponentTypeId(c_context, TypenameAsString(), &tid);\n if (code != GXF_SUCCESS) {\n return Unexpected{code};\n }\n FixedVector> components;\n components.reserve(N);\n for (int offset = 0; static_cast(offset) < N; offset++) {\n gxf_uid_t cid;\n const gxf_result_t code = GxfComponentFind(c_context, c_eid, tid, nullptr, &offset, &cid);\n if (code != GXF_SUCCESS) {\n break;\n }\n const auto result = Handle::Create(c_context, cid)\n .map([&](Handle component) {\n return components.push_back(component)\n .substitute_error(GXF_EXCEEDING_PREALLOCATED_SIZE);\n });\n if (!result) {\n return ForwardError(result);\n }\n }\n return components;\n }\n\n /**\n * @brief Returns the pointer to Entity Item for the entity\n *\n * @return void * entity item ptr\n */\n void* entity_item_ptr() const {\n check_entity_item_ptr();\n return entity_item_ptr_;\n }\n\n private:\n /**\n * @brief Set the entity item ptr if its not set already\n *\n * @return Expected Success or error code\n */\n Expected check_entity_item_ptr() const {\n if (entity_item_ptr_ != nullptr) {\n return Success;\n }\n auto code = GxfEntityGetItemPtr(context(), eid(),\n reinterpret_cast(&(entity_item_ptr_)));\n return code == GXF_SUCCESS ? Success : Unexpected(code);\n }\n\n void release() {\n GxfEntityRefCountDec(context_, eid_); // TODO(v2) We should use the error code, but we can't\n // do anything about it..\n eid_ = kNullUid;\n entity_item_ptr_ = nullptr;\n }\n\n gxf_context_t context_ = kNullContext;\n gxf_uid_t eid_ = kNullUid;\n mutable void* entity_item_ptr_ = nullptr;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CORE_ENTITY_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/expected.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_EXPECTED_HPP\n#define NVIDIA_GXF_CORE_EXPECTED_HPP\n\n#include \n#include \n\n#include \"common/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Expected type for GXF which uses gxf_result_t as error code.\ntemplate \nusing Expected = Expected;\n\n// Unexpected type for GXF which uses gxf_result_t as error code.\nusing Unexpected = Unexpected;\n\n// Special value which can be used instead of {} to return from a function which returns an\n// Expected.\nconst Expected Success{};\n\n// Extracts the error code as an unexpected.\ntemplate \nUnexpected ForwardError(const Expected& expected) {\n return Unexpected{expected.error()};\n}\n\n// Extracts the error code as an unexpected.\ntemplate \nUnexpected ForwardError(Expected&& expected) {\n return Unexpected{std::move(expected.error())};\n}\n\n// Interprets an expected as a result code. Returns GXF_SUCESS if the result has a value and the\n// result's error code otherwise.\ntemplate \ngxf_result_t ToResultCode(const Expected& result) {\n return result ? GXF_SUCCESS : result.error();\n}\n\n// If the result code is GXF_SUCCESS the function returns Success, otherwise it returns an\n// unexpected with the given error code.\ninline\nExpected ExpectedOrCode(gxf_result_t code) {\n if (code == GXF_SUCCESS) {\n return Success;\n } else {\n return Unexpected{code};\n }\n}\n\n// If the result code is GXF_SUCCESS the function returns the given value, otherwise it returns an\n// unexpected with the given error code.\ntemplate \nExpected>>\nExpectedOrCode(gxf_result_t code, T&& value) {\n if (code == GXF_SUCCESS) {\n return std::forward(value);\n } else {\n return Unexpected{code};\n }\n}\n\ntemplate \nExpected>>\nExpectedOrError(const Expected& code, T&& value) {\n if (code) {\n return std::forward(value);\n } else {\n return ForwardError(code);\n }\n}\n\ninline\ngxf_result_t AccumulateError(gxf_result_t previous, gxf_result_t current) {\n return current != GXF_SUCCESS ? current : previous;\n}\n\ninline\nExpected AccumulateError(Expected previous, Expected current) {\n return !current ? current : previous;\n}\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/expected_macro.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#pragma once\n\n#include \n\n#include \"gxf/core/common_expected_macro.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"magic_enum.hpp\" // NOLINT(build/include)\n\n//////////////////////////////////////////\n// Configuration for using bool as status:\n//////////////////////////////////////////\nnamespace nvidia::expected_macro {\n\n// This section contains the configuration to use the expected macro with\n// different return types like bool, int, std::optional (and in the future std::expected).\ntemplate <>\nstruct IsStatus : std::true_type {};\n\ntemplate <>\nconstexpr bool DefaultError() {\n return false;\n}\n\ntemplate <>\nstruct StatusName {\n static std::string Get(bool status) { return status ? \"Success\" : \"Failure\"; }\n};\n\n/////////////////////////////////////////\n// Configuration for using int as status:\n/////////////////////////////////////////\ntemplate <>\nstruct IsStatus : std::true_type {};\n\ntemplate <>\nconstexpr bool IsValid(const int& status) {\n return status == 0;\n}\n\ntemplate <>\nconstexpr int DefaultError() {\n return 1;\n}\n\ntemplate <>\nstruct StatusName {\n static std::string Get(int status) { return std::to_string(status); }\n};\n\n//////////////////////////////////////////\n// Configuration for using enum as status:\n//////////////////////////////////////////\ntemplate \nstruct StatusName>> {\n static std::string Get(EnumStatus status) { return std::string(magic_enum::enum_name(status)); }\n};\n\n////////////////////////////////////////////////////////\n// Configuration for using std::optional as unwrappable:\n////////////////////////////////////////////////////////\ntemplate \nstruct IsUnwrappable> : std::true_type {};\n\ntemplate \nstruct StatusType> {\n using Type = bool;\n};\n\ntemplate \nstruct StatusValue> {\n static constexpr bool Get(const std::optional& optional) { return optional.has_value(); }\n};\n\ntemplate \nstruct InvalidUnwrappable, bool> {\n static std::optional Get(bool status) { return std::nullopt; }\n};\n\n///////////////////////////////////////////////////////////\n// Configuration for using nvidia::Expected as unwrappable:\n///////////////////////////////////////////////////////////\ntemplate \nstruct IsUnwrappable<::nvidia::Expected> : std::true_type {};\n\ntemplate \nstruct StatusType<::nvidia::Expected> {\n using Type = Status;\n};\n\ntemplate \nstruct StatusValue<::nvidia::Expected> {\n static constexpr Status Get(const ::nvidia::Expected& expected) {\n return expected.error();\n }\n};\n\ntemplate \nstruct InvalidUnwrappable<::nvidia::Expected, Status> {\n static ::nvidia::Expected Get(Status status) {\n return ::nvidia::Unexpected(status);\n }\n};\n\n// This customizes the expected macro, s.t. it can be used with gxf_result_t.\ntemplate <>\nstruct IsStatus : std::true_type {};\n\ntemplate <>\nconstexpr bool IsValid(const gxf_result_t& status) {\n return status == GXF_SUCCESS;\n}\n\ntemplate <>\nconstexpr gxf_result_t DefaultError() {\n return GXF_FAILURE;\n}\n\ntemplate <>\nstruct StatusName {\n static std::string Get(gxf_result_t status) { return GxfResultStr(status); }\n};\n\n// For back-compatibility we define an alias to the original name of the macro when it was gxf\n// specific.\n#define GXF_RETURN_IF_ERROR RETURN_IF_ERROR\n#define GXF_UNWRAP_OR_RETURN UNWRAP_OR_RETURN\n} // namespace nvidia::expected_macro\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/filepath.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_FILEPATH_HPP_\n#define NVIDIA_GXF_CORE_FILEPATH_HPP_\n\n#include \n#include \"yaml-cpp/yaml.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n\n// Specialization of ParameterParser for a file parameter type to identify parameters that are file\n// system paths\nstruct FilePath : public std::string {\n FilePath() : std::string() {}\n\n FilePath(const char* s) : std::string(s) {}\n\n FilePath(const std::string& str) : std::string(str) {}\n};\n\n\n} // namespace gxf\n} // namespace nvidia\n\ntemplate<>\nstruct YAML::convert {\n static Node encode(const nvidia::gxf::FilePath& data) {\n Node node = YAML::Load(data);\n return node;\n }\n\n static bool decode(const Node& node, nvidia::gxf::FilePath& data) {\n if (!node.IsScalar()) {\n return false;\n }\n data = node.as();\n return true;\n }\n};\n\n\n\n#endif // NVIDIA_GXF_CORE_FILEPATH_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/gxf.h", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_GXF_H_\n#define NVIDIA_GXF_CORE_GXF_H_\n\n#ifdef __cplusplus\n#include \n#include \n#else\n#include \n#endif\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// -- Result type --------------------------------------------------------------------------------\n\n/// @brief GXF error and result codes which are used by almost all GXF functions.\ntypedef enum {\n GXF_SUCCESS = 0,\n GXF_FAILURE = 1,\n\n GXF_NOT_IMPLEMENTED,\n GXF_FILE_NOT_FOUND,\n GXF_INVALID_ENUM,\n GXF_NULL_POINTER,\n GXF_UNINITIALIZED_VALUE,\n\n GXF_ARGUMENT_NULL,\n GXF_ARGUMENT_OUT_OF_RANGE,\n GXF_ARGUMENT_INVALID,\n\n GXF_OUT_OF_MEMORY,\n GXF_MEMORY_INVALID_STORAGE_MODE,\n\n GXF_CONTEXT_INVALID,\n\n GXF_EXTENSION_NOT_FOUND,\n GXF_EXTENSION_FILE_NOT_FOUND,\n GXF_EXTENSION_NO_FACTORY,\n\n GXF_FACTORY_TOO_MANY_COMPONENTS,\n GXF_FACTORY_DUPLICATE_TID,\n GXF_FACTORY_UNKNOWN_TID,\n GXF_FACTORY_ABSTRACT_CLASS,\n GXF_FACTORY_UNKNOWN_CLASS_NAME,\n GXF_FACTORY_INVALID_INFO,\n GXF_FACTORY_INCOMPATIBLE,\n\n GXF_ENTITY_NOT_FOUND,\n GXF_ENTITY_NAME_EXCEEDS_LIMIT,\n GXF_ENTITY_COMPONENT_NOT_FOUND,\n GXF_ENTITY_COMPONENT_NAME_EXCEEDS_LIMIT,\n GXF_ENTITY_CAN_NOT_ADD_COMPONENT_AFTER_INITIALIZATION,\n GXF_ENTITY_CAN_NOT_REMOVE_COMPONENT_AFTER_INITIALIZATION,\n GXF_ENTITY_MAX_COMPONENTS_LIMIT_EXCEEDED,\n\n GXF_PARAMETER_NOT_FOUND,\n GXF_PARAMETER_ALREADY_REGISTERED,\n GXF_PARAMETER_INVALID_TYPE,\n GXF_PARAMETER_OUT_OF_RANGE,\n GXF_PARAMETER_NOT_INITIALIZED,\n GXF_PARAMETER_CAN_NOT_MODIFY_CONSTANT,\n GXF_PARAMETER_PARSER_ERROR,\n GXF_PARAMETER_NOT_NUMERIC,\n GXF_PARAMETER_MANDATORY_NOT_SET,\n\n GXF_CONTRACT_INVALID_SEQUENCE,\n GXF_CONTRACT_PARAMETER_NOT_SET,\n GXF_CONTRACT_MESSAGE_NOT_AVAILABLE,\n\n GXF_INVALID_LIFECYCLE_STAGE,\n GXF_INVALID_EXECUTION_SEQUENCE,\n GXF_REF_COUNT_NEGATIVE,\n GXF_RESULT_ARRAY_TOO_SMALL,\n\n GXF_INVALID_DATA_FORMAT,\n\n GXF_EXCEEDING_PREALLOCATED_SIZE,\n\n GXF_QUERY_NOT_ENOUGH_CAPACITY,\n GXF_QUERY_NOT_APPLICABLE,\n GXF_QUERY_NOT_FOUND,\n\n GXF_NOT_FINISHED,\n\n GXF_HTTP_GET_FAILURE,\n GXF_HTTP_POST_FAILURE,\n\n GXF_ENTITY_GROUP_NOT_FOUND,\n GXF_RESOURCE_NOT_INITIALIZED,\n GXF_RESOURCE_NOT_FOUND,\n\n GXF_CONNECTION_BROKEN,\n GXF_CONNECTION_ATTEMPTS_EXCEEDED,\n\n GXF_IPC_CONNECTION_FAILURE,\n GXF_IPC_CALL_FAILURE,\n GXF_IPC_SERVICE_NOT_FOUND,\n} gxf_result_t;\n\n/// @brief Checks if a result code is GXF_SUCCESS or not\n///\n/// @param result A GXF result code\n/// @return A boolean value indicating if the result code is GXF_SUCCESS\nbool isSuccessful(gxf_result_t result);\n\n/// @brief Gets a string describing an GXF error code.\n///\n/// The caller does not get ownership of the return C string and must not delete it.\n///\n/// @param result A GXF error code\n/// @return A pointer to a C string with the error code description.\nconst char* GxfResultStr(gxf_result_t result);\n\n// -- Unique identifiers -------------------------------------------------------------------------\n\n/// @brief Type of unique GXF object identifiers (UID/uid)\n///\n/// Uids are used to reference entities and components throughout the GXF API.\ntypedef int64_t gxf_uid_t;\n\n/// @brief A GXF UID which can be used to indicate an invalid or unused GXF UID.\n#define kNullUid 0L\n/// @brief A GXF UID which can be used to indicate an unspecified component during\n/// graph load operation. This component should be updated in a subsequent\n/// graph/parameters file. Failing to do so will result in an error during graph activation\n#define kUnspecifiedUid -1L\n\n/// @brief Type of unique GXF type identifier (TID/tid)\n///\n/// Tids are used to uniquely identify the type of a component, instead of for example using\n/// a string with the type name.\ntypedef struct {\n uint64_t hash1;\n uint64_t hash2;\n} gxf_tid_t;\n\n/// @brief Gives the null value of a GXF tid\n///\n/// The null tid is used to mark a tid as invalid or to indicate that a tid is not set.\n///\n/// @return The null tid\ninline gxf_tid_t GxfTidNull() {\n gxf_tid_t result;\n result.hash1 = 0UL;\n result.hash2 = 0UL;\n return result;\n}\n\n/// @brief Determines if a GXF tid is null\n///\n/// @param tid A GXF tid\n/// @return Returns 1 if 'tid' is the null tid; and 0 otherwise.\ninline uint32_t GxfTidIsNull(gxf_tid_t tid) {\n return (tid.hash1 == 0UL && tid.hash2 == 0UL) ? 1 : 0;\n}\n\n// -- Context ------------------------------------------------------------------------------------\n\n/// @brief Type for context handle\ntypedef void* gxf_context_t;\n\n/// @brief An invalid context\n#define kNullContext nullptr\n\n/// @brief GXF Core Version\n#define kGxfCoreVersion \"5.1.0\"\n\n/// @brief Creates a new GXF context\n///\n/// A GXF context is required for all almost all GXF operations. The context must be destroyed with\n/// 'GxfContextDestroy'. Multiple contexts can be created in the same process, however they can not\n/// communicate with each other.\n///\n/// @param context The new GXF context is written to the given pointer.\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfContextCreate(gxf_context_t* context);\n\n/// @brief Creates a new runtime context from shared context.\n///\n/// A shared runtime context is used for sharing entities between graphs running\n/// within the same process.\n///\n/// @param shared A valid GXF shared context.\n/// @param context The new GXF context is written to the given pointer.\ngxf_result_t GxfContextCreateShared(gxf_context_t shared, gxf_context_t* context);\n\n/// @brief Gets a GXF shared context.\n///\n/// A GXF context is required for all almost all GXF operations. The context\n/// must be destroyed with 'GxfContextDestroy'. A shared runtime context is used\n/// for sharing entities between graphs running within the same process.\n///\n/// @param shared The shared GXF context is written to this pointer.\n/// @param context A valid GXF context\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the\n/// GXF error codes.\ngxf_result_t GxfGetSharedContext(gxf_context_t context, gxf_context_t* shared);\n\n/// @brief Destroys a GXF context\n///\n/// Every GXF context must be destroyed by calling this function. The context must have been\n/// previously created with 'GxfContextCreate'. This will also destroy all entities and components\n/// which were created as part of the context.\n///\n/// @param context A valid GXF context.\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfContextDestroy(gxf_context_t context);\n\n// -- Extensions ---------------------------------------------------------------------------------\n\n/// @brief Maximum number of extensions in a context\n#define kMaxExtensions 1024\n\n/// @brief Loads an extension from a pointer to the Extension object.\n///\n/// `extension_ptr` must be a pointer to a valid object with `Extension` type.\n/// @param context A valid GXF context\n/// @param extension_ptr A pointer to Extension\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfLoadExtensionFromPointer(gxf_context_t context, void* extension_ptr);\n\n/// @brief Registers a component with a GXF extension\n///\n/// A GXF extension need to register all of its components in the extension factory function. For\n/// convenience the helper macros in gxf/std/extension_factory_helper.hpp can be used.\n///\n/// The developer must choose a unique GXF tid with two random 64-bit integers. The developer\n/// must ensure that every GXF component has a unique tid. The name of the component must be\n/// the fully qualified C++ type name of the component. A component may only have a single base\n/// class and that base class must be specified with its fully qualified C++ type name as the\n/// parameter 'base_name'.\n///\n/// @see gxf/std/extension_factory_helper.hpp\n/// @see core/type_name.hpp\n///\n/// @param context A valid GXF context\n/// @param tid The chosen GXF tid\n/// @param name The type name of the component\n/// @param base_name The type name of the base class of the component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfRegisterComponent(gxf_context_t context, gxf_tid_t tid, const char* name,\n const char* base_name);\n\n/// @brief Registers a new component from an extension during runtime\n///\n/// Once an extension is loaded any newly added components to that extension can be registered\n/// with the context using this function\n///\n/// @param context A valid GXF context\n/// @param component_tid The valid GXF tid of a unregistered new component\n/// @param extension_tid The valid GXF tid of an extension which has already been loaded\n\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfRegisterComponentInExtension(gxf_context_t context, gxf_tid_t component_tid,\n gxf_tid_t extension_tid);\n\n// -- Entities -----------------------------------------------------------------------------------\n\n/// @brief Maximum number of entities in a context\n#define kMaxEntities 1024\n\n/// @brief various lifecycle states of an entity\ntypedef enum {\n GXF_ENTITY_STATUS_NOT_STARTED = 0,\n GXF_ENTITY_STATUS_START_PENDING,\n GXF_ENTITY_STATUS_STARTED,\n GXF_ENTITY_STATUS_TICK_PENDING,\n GXF_ENTITY_STATUS_TICKING,\n GXF_ENTITY_STATUS_IDLE,\n GXF_ENTITY_STATUS_STOP_PENDING,\n GXF_ENTITY_MAX\n} gxf_entity_status_t;\n\n/// @brief Gets a string describing an GXF entity status.\n///\n/// The caller does not get ownership of the return C string and must not delete it.\n///\n/// @param status A GXF entity status\n/// @return A pointer to a C string with the entity status description.\nconst char* GxfEntityStatusStr(gxf_entity_status_t status);\n\n/// @brief Used by behavior parent codelet in Behavior Tree denoting the result\n/// of codelet::tick()\n/// - GXF_BEHAVIOR_INIT is for codelet that have not yet started running.\n/// - GXF_BEHAVIOR_SUCCESS is for codelet that terminates with success after\n/// ticking\n/// - GXF_BEHAVIOR_RUNNING is for codelet that needs multiple ticks to complete\n/// - GXF_BEHAVIOR_FAILURE is for codelet that terminates with failure after\n/// ticking\n/// - GXF_BEHAVIOR_UNKNOWN is for non-behavior-tree codelet because we don't\n/// care about the behavior status returned by controller if it is not a BT\n/// codelet\ntypedef enum {\n GXF_BEHAVIOR_INIT = 0,\n GXF_BEHAVIOR_SUCCESS = 1,\n GXF_BEHAVIOR_RUNNING = 2,\n GXF_BEHAVIOR_FAILURE = 3,\n GXF_BEHAVIOR_UNKNOWN = 4,\n} entity_state_t;\n\n/// @brief Activates a previously created and inactive entity\n///\n/// Activating an entity generally marks the official start of its lifetime and has multiple\n/// implications:\n/// - If mandatory parameters, i.e. parameter which do not have the flag \"optional\", are not set\n/// the operation will fail.\n/// - All components on the entity are initialized.\n/// - All codelets on the entity are scheduled for execution. The scheduler will start calling\n/// start, tick and stop functions as specified by scheduling terms.\n/// - After activation trying to change a dynamic parameters will result in a failure.\n/// - Adding or removing components of an entity after activation will result in a failure.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @return GXF error code\ngxf_result_t GxfEntityActivate(gxf_context_t context, gxf_uid_t eid);\n\n/// @brief Deactivates a previously activated entity\n///\n/// Deactivating an entity generally marks the official end of its lifetime and has multiple\n/// implications:\n/// - All codelets are removed from the schedule. Already running entities are run to completion.\n/// - All components on the entity are deinitialized.\n/// - Components can be added or removed again once the entity was deactivated.\n/// - Mandatory and non-dynamic parameters can be changed again.\n///\n/// Note: In case that the entity is currently executing this function will wait and block until\n/// the current execution is finished.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @return GXF error code\ngxf_result_t GxfEntityDeactivate(gxf_context_t context, gxf_uid_t eid);\n\n/// @brief Destroys a previously created entity\n///\n/// Destroys an entity immediately. The entity is destroyed even if the reference count has not\n/// yet reached 0. If the entity is active it is deactivated first.\n///\n/// Note: This function can block for the same reasons as 'GxfEntityDeactivate'.\n///\n/// @param context A valid GXF context\n/// @param eid The returned UID of the created entity\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityDestroy(gxf_context_t context, gxf_uid_t eid);\n\n/// @brief Finds an entity by its name\n///\n/// @param context A valid GXF context\n/// @param name A C string with the name of the entity. Ownership is not transferred.\n/// @param eid The returned UID of the entity\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityFind(gxf_context_t context, const char* name, gxf_uid_t* eid);\n\n/// @brief Finds all entities in the current application\n///\n/// Finds and returns all entity ids for the current application. If more than `max_entities` exist\n/// only `max_entities` will be returned. The order and selection of entities returned is arbitrary.\n///\n/// @param context A valid GXF context\n/// @param num_entities In/Out: the max number of entities that can fit in the buffer/the number of\n/// entities that exist in the application\n/// @param entities A buffer allocated by the caller for returned UIDs of all entities, with\n/// capacity for `num_entities`.\n/// @return GXF_SUCCESS if the operation was successful, GXF_QUERY_NOT_ENOUGH_CAPACITY if more\n/// entities exist in the application than `max_entities`, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityFindAll(gxf_context_t context, uint64_t* num_entities, gxf_uid_t* entities);\n\n/// @brief Increases the reference count for an entity by 1.\n///\n/// By default reference counting is disabled for an entity. This means that entities created with\n/// 'GxfCreateEntity' are not automatically destroyed. If this function is called for an entity\n/// with disabled reference count, reference counting is enabled and the reference count is set to\n/// 1. Once reference counting is enabled an entity will be automatically destroyed if the reference\n/// count reaches zero, or if 'GxfEntityDestroy' is called explicitly.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityRefCountInc(gxf_context_t context, gxf_uid_t eid);\n\n/// @brief Decreases the reference count for an entity by 1.\n///\n/// See 'GxfEntityRefCountInc' for more details on reference counting.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityRefCountDec(gxf_context_t context, gxf_uid_t eid);\n\n/// @brief Provides the reference count for an entity.\n///\n/// See 'GxfEntityRefCountInc' for more details on reference counting.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @param count The reference count of a valid entity\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityGetRefCount(gxf_context_t context, gxf_uid_t eid, int64_t* count);\n\n/// @brief Gets the status of the entity.\n///\n/// See 'gxf_entity_status_t' for the various status.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @param entity_status output; status of an entity eid\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityGetStatus(gxf_context_t context, gxf_uid_t eid,\n gxf_entity_status_t* entity_status);\n\n/// @brief Gets the name of the entity.\n///\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @param entity_name output; name of the entity\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityGetName(gxf_context_t context, gxf_uid_t eid,\n const char** entity_name);\n\n/// @brief Gets the state of the entity.\n///\n/// See 'entity_state_t' for the various status.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @param entity_state output; behavior status of an entity eid used by the\n/// behavior tree parent codelet\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the\n/// GXF error codes\ngxf_result_t GxfEntityGetState(gxf_context_t context, gxf_uid_t eid,\n entity_state_t* entity_state);\n\n/// @brief Notifies the occurrence of an event and inform the scheduler to check\n/// the status of the entity\n///\n/// The entity must have an 'AsynchronousSchedulingTerm' scheduling term\n/// component and it must be in \"EVENT_WAITING\" state for the notification to be\n/// acknowledged.\n///\n/// See 'AsynchronousEventState' for various states\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the\n/// GXF error codes.\n\ngxf_result_t GxfEntityEventNotify(gxf_context_t context, gxf_uid_t eid);\n\n/// @brief Various type of events used to communicate with a GXF scheduler\n///\n/// GXF_EVENT_EXTERNAL is supported by all GXF schedulers and the rest of the event types\n/// are supported by event based scheduler only. GXF_EVENT_EXTERNAL is typically intended\n/// to be used by events originating outside of the GXF framework by threads which are not\n/// owned by GXF. All other event types occur within GXF and each of them describe a specific\n/// event trigger scenario\n\ntypedef enum {\n GXF_EVENT_CUSTOM = 0,\n GXF_EVENT_EXTERNAL = 1,\n GXF_EVENT_MEMORY_FREE = 2,\n GXF_EVENT_MESSAGE_SYNC = 3,\n GXF_EVENT_TIME_UPDATE = 4,\n GXF_EVENT_STATE_UPDATE = 5,\n} gxf_event_t;\n\ngxf_result_t GxfEntityNotifyEventType(gxf_context_t context, gxf_uid_t eid, gxf_event_t event);\n\n/// @brief Gets a string describing an GXF event type\n///\n/// The caller does not get ownership of the return C string and must not delete it.\n///\n/// @param result A GXF error code\n/// @return A pointer to a C string with the error code description.\nconst char* GxfEventStr(gxf_event_t event);\n\n// -- Components ---------------------------------------------------------------------------------\n\n/// @brief Maximum number of components in an entity or extension\n#define kMaxComponents 1024\n\n/// @brief Maximum number of characters in the name of an entity\n#define kMaxEntityNameSize 2048\n\n/// @brief Maximum number of characters in the name of a component\n#define kMaxComponentNameSize 256\n\n/// @brief Gets the GXF unique type ID (TID) of a component\n///\n/// Get the unique type ID which was used to register the component with GXF. The function expects\n/// the fully qualified C++ type name of the component including namespaces.\n///\n/// Example of a valid component type name: \"nvidia::gxf::PingTx\"\n///\n/// @param context A valid GXF context\n/// @param name The fully qualified C++ type name of the component\n/// @param tid The returned TID of the component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentTypeId(gxf_context_t context, const char* name, gxf_tid_t* tid);\n\n/// @brief Gets the fully qualified C++ type name GXF component typename from a TID\n///\n/// Get the unique typename of the component with which it was registered using one of\n/// the GXF_EXT_FACTORY_ADD*() macros\n///\n/// @param context A valid GXF context\n/// @param tid The unique type ID (TID) of the component with which the component was registered\n/// @param name The returned name of the component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentTypeName(gxf_context_t context, gxf_tid_t tid, const char** name);\n\n/// @brief Gets the fully qualified C++ type name GXF component typename from a UID\n///\n/// Get the unique typename of the component with which it was registered using one of\n/// the GXF_EXT_FACTORY_ADD*() macros\n///\n/// @param context A valid GXF context\n/// @param cid The UID of a valid component\n/// @param name The returned typename of the component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentTypeNameFromUID(gxf_context_t context, gxf_uid_t cid, const char** name);\n\n/// @brief Gets the name of a component\n///\n/// Each component has a user-defined name which was used in the call to 'GxfComponentAdd'.\n/// Usually the name is specified in the GXF application file.\n///\n/// @param context A valid GXF context\n/// @param cid The unique object ID (UID) of the component\n/// @param name The returned name of the component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentName(gxf_context_t context, gxf_uid_t cid, const char** name);\n\n/// @brief Gets the unique object ID of the entity of a component\n///\n/// Each component has a unique ID with respect to the context and is stored in one entity. This\n/// function can be used to retrieve the ID of the entity to which a given component belongs.\n///\n/// @param context A valid GXF context\n/// @param cid The unique object ID (UID) of the component\n/// @param eid The returned unique object ID (UID) of the entity\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentEntity(gxf_context_t context, gxf_uid_t cid, gxf_uid_t* eid);\n\n/// @brief Gets the pointer to an entity item\n///\n/// Each entity has a unique ID with respect to the context and is stored in the entity warden. This\n/// function can be used to retrieve the pointer to entity item stored in the entity warden for a\n/// given entity id.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of the entity\n/// @param ptr The returned pointer to the entity item\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityGetItemPtr(gxf_context_t context, gxf_uid_t eid, void** ptr);\n\n/// @brief Adds a new component to an entity\n///\n/// An entity can contain multiple components and this function can be used to add a new component\n/// to an entity. A component must be added before an entity is activated, or after it was\n/// deactivated. Components must not be added to active entities. The order of components is stable\n/// and identical to the order in which components are added (see 'GxfComponentFind').\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of the entity to which the component is added.\n/// @param tid The unique type ID (TID) of the component to be added to the entity.\n/// @param name The name of the new component. Ownership is not transferred.\n/// @param cid The returned UID of the created component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentAdd(gxf_context_t context, gxf_uid_t eid, gxf_tid_t tid, const char* name,\n gxf_uid_t* cid);\n\n/// @brief Adds a new component to an entity\n///\n/// An entity can contain multiple components and this function can be used to add a new component\n/// to an Entity. A component must be added before an entity is activated, or after it was\n/// deactivated. Components must not be added to active entities. The order of components is stable\n/// and identical to the order in which components are added (see 'GxfComponentFind').\n///\n/// @param context A valid GXF context\n/// @param item_ptr The pointer to entity item\n/// @param tid The unique type ID (TID) of the component to be added to the entity.\n/// @param name The name of the new component. Ownership is not transferred.\n/// @param cid The returned UID of the created component\n/// @param comp_ptr The returned pointer to the created component object\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentAddAndGetPtr(gxf_context_t context, void* item_ptr, gxf_tid_t tid,\n const char* name, gxf_uid_t* cid, void ** comp_ptr);\n\n/// @brief Removes a component from an entity\n///\n/// An entity can contain multiple components and this function can be used to remove a component\n/// from an entity. A component must be removed before an entity is activated, or after it was\n/// deactivated. Components must not be removed from active entities.\n///\n/// @param context A valid GXF context\n/// @param cid The UID of the component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentRemoveWithUID(gxf_context_t context, gxf_uid_t cid);\n\n/// @brief Removes a component from an entity\n///\n/// An entity can contain multiple components and this function can be used to remove a component\n/// from an entity. A component must be removed before an entity is activated, or after it was\n/// deactivated. Components must not be removed from active entities.\n///\n/// @brief Adds an existing component to the interface of an entity\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of the entity to which the component is added.\n/// @param tid The unique type ID (TID) of the component to be added to the entity.\n/// @param name The name of the new component. Ownership is not transferred.\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentRemove(gxf_context_t context, gxf_uid_t eid, gxf_tid_t tid,\n const char * name);\n\n/// An entity can holds references to other components in its interface, so that when finding a\n/// component in an entity, both the component this entity holds and those it refers to will be\n/// returned.\n/// This supports the case when an entity contains a subgraph, then those components that has been\n/// declared in the subgraph interface will be put to the interface of the parent entity.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of the entity to which the component is added.\n/// @param cid The unique object ID of the component\n/// @param name The name of the new component. Ownership is not transferred.\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentAddToInterface(gxf_context_t context, gxf_uid_t eid,\n gxf_uid_t cid, const char* name);\n\n/// @brief Finds a component in an entity\n///\n/// Searches components in an entity which satisfy certain criteria: component type, component\n/// name, and component min index. All three criteria are optional; in case no criteria is given\n/// the first component is returned. The main use case for \"component min index\" is a repeated\n/// search which continues at the index which was returned by a previous search.\n///\n/// In case no entity with the given criteria was found GXF_ENTITY_NOT_FOUND is returned.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of the entity which is searched.\n/// @param tid The component type ID (TID) of the component to find (optional)\n/// @param name The component name of the component to find (optional). Ownership not transferred.\n/// @param offset The index of the first component in the entity to search. Also contains the index\n/// of the component which was found.\n/// @param cid The returned UID of the searched component\n/// @return GXF_SUCCESS if a component matching the criteria was found, GXF_ENTITY_NOT_FOUND if no\n/// component matching the criteria was found, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentFind(gxf_context_t context, gxf_uid_t eid, gxf_tid_t tid, const char* name,\n int32_t* offset, gxf_uid_t* cid);\n\n/// @brief Finds a component in an entity and returns pointer to component\n///\n/// Searches components in an entity which satisfy certain criteria: component type, component name\n/// . All two criteria are optional; in case no criteria is given the first component is returned\n/// The main use case for \"component min index\" is a repeated search which continues at the index\n/// which was returned by a previous search.\n///\n/// In case no entity with the given criteria was found GXF_ENTITY_NOT_FOUND is returned.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of the entity which is searched.\n/// @param item_ptr The pointer to entity item\n/// @param tid The component type ID (TID) of the component to find (optional)\n/// @param name The component name of the component to find (optional). Ownership not transferred.\n/// @param offset The index of the first component in the entity to search. Also contains the index\n/// of the component which was found.\n/// @param cid The returned UID of the searched component\n/// @param ptr The returned pointer of the searched component\n/// @return GXF_SUCCESS if a component matching the criteria was found, GXF_ENTITY_NOT_FOUND if no\n/// component matching the criteria was found, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentFindAndGetPtr(gxf_context_t context, gxf_uid_t eid, void* item_ptr,\n gxf_tid_t tid, const char* name, int32_t* offset,\n gxf_uid_t* cid, void** ptr);\n\n/// @brief Finds all components in an entity\n///\n/// Finds and returns all component ids for the given entity. If more than `num_cids` exist\n/// GXF_QUERY_NOT_ENOUGH_CAPACITY will be returned and `num_cids` will be updated to the actual\n/// number of components in the entity.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of the entity which is searched.\n/// @param num_cids In/Out: the max number of components that can fit in the buffer/the number of\n/// components that exist in the entity\n/// @param cids A buffer allocated by the caller for returned UIDs of all components, with\n/// capacity for `num_cids`.\n/// @return GXF_SUCCESS if the operation was successful, GXF_QUERY_NOT_ENOUGH_CAPACITY if more\n/// components exist in the entity than `num_cids`, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentFindAll(gxf_context_t context, gxf_uid_t eid, uint64_t* num_cids,\n gxf_uid_t* cids);\n\n/// @brief Gets the component type ID (TID) of a component\n///\n/// @param context A valid GXF context\n/// @param cid The component object ID (UID) for which the component type is requested.\n/// @param tid The returned TID of the component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentType(gxf_context_t context, gxf_uid_t cid, gxf_tid_t* tid);\n\n/// @brief Verifies that a component exists, has the given type, gets a pointer to it.\n///\n/// @param context A valid GXF context\n/// @param tid The expected component type ID (TID) of the component\n/// @param pointer The returned pointer to the component object.\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentPointer(gxf_context_t context, gxf_uid_t uid, gxf_tid_t tid,\n void** pointer);\n\n/// @brief Check if a registered type in an extension is derived from another registered type\n/// from the same or any other extension. This is useful query the component hierarchies using\n/// their type id's. Both the derived and base types have to be registered in an extension via\n/// one of the registered via GXF_EXT_FACTORY_ADD* macros.\n///\n/// @param context A valid GXF context\n/// @param derived The type ID (TID) of a derived type\n/// @param base The type ID (TID) of a base type\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfComponentIsBase(gxf_context_t context, gxf_tid_t derived, gxf_tid_t base,\n bool* result);\n\n// -- Parameter ----------------------------------------------------------------------------------\n\n/// @brief Maximum number of parameters in a component\n#define kMaxParameters 1024\n\n/// @brief [experimental] The name of the parameter which stores the name of a component\n#define kInternalNameParameterKey \"__name\"\n\n/// @brief Flags describing the behavior of parameter\n///\n/// Parameter flags are specified when a parameter is registered as part of the component interface.\n/// Multiple flags can be OR combined.\nenum gxf_parameter_flags_t_ {\n /// No additional flags are set (the default). This means the parameter is mandatory and static.\n /// The parameter must be set before entity activation and can not be changed after entity\n /// activation.\n GXF_PARAMETER_FLAGS_NONE = 0,\n /// The parameter value is optional and might not be available after entity activation.\n /// This implies that it is not allowed to access the parameter with 'get()' in the C++ API.\n /// Instead 'try_get' must be used.\n GXF_PARAMETER_FLAGS_OPTIONAL = 1,\n /// The parameter is dynamic an might change after entity activation. However it is still\n /// guaranteed that parameters do not change during the initialize, deinitialize, start, tick,\n /// or stop functions.\n GXF_PARAMETER_FLAGS_DYNAMIC = 2\n};\n\n/// @brief Type used for parameter flags.\n///\n/// @see gxf_parameter_flags_t_\ntypedef uint32_t gxf_parameter_flags_t;\n\n// Sets a 8-bit signed integer parameter\ngxf_result_t GxfParameterSetInt8(gxf_context_t context, gxf_uid_t uid, const char* key,\n int8_t value);\n// Sets a 16-bit signed integer parameter\ngxf_result_t GxfParameterSetInt16(gxf_context_t context, gxf_uid_t uid, const char* key,\n int16_t value);\n// Sets a 32-bit signed integer parameter\ngxf_result_t GxfParameterSetInt32(gxf_context_t context, gxf_uid_t uid, const char* key,\n int32_t value);\n// Sets a 64-bit signed integer parameter\ngxf_result_t GxfParameterSetInt64(gxf_context_t context, gxf_uid_t uid, const char* key,\n int64_t value);\n// Sets a 8-bit unsigned integer parameter\ngxf_result_t GxfParameterSetUInt8(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint8_t value);\n// Sets a 16-bit unsigned integer parameter\ngxf_result_t GxfParameterSetUInt16(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint16_t value);\n// Sets a 32-bit unsigned integer parameter\ngxf_result_t GxfParameterSetUInt32(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint32_t value);\n// Sets a 64-bit unsigned integer parameter\ngxf_result_t GxfParameterSetUInt64(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t value);\n// Sets a 32-bit floating point parameter\ngxf_result_t GxfParameterSetFloat32(gxf_context_t context, gxf_uid_t uid, const char* key,\n float value);\n// Sets a 64-bit floating point parameter\ngxf_result_t GxfParameterSetFloat64(gxf_context_t context, gxf_uid_t uid, const char* key,\n double value);\n// Sets a string parameter\ngxf_result_t GxfParameterSetStr(gxf_context_t context, gxf_uid_t uid, const char* key,\n const char* value);\n// Sets a handle parameter\ngxf_result_t GxfParameterSetHandle(gxf_context_t context, gxf_uid_t uid, const char* key,\n gxf_uid_t cid);\n// Sets a boolean parameter\ngxf_result_t GxfParameterSetBool(gxf_context_t context, gxf_uid_t uid, const char* key,\n bool value);\n\n// Sets a String 1D-Vector parameter. Internally the data is stored in\n// a std::vector. The length of the vector should match the length of the registered parameter.\ngxf_result_t GxfParameterSet1DStrVector(gxf_context_t context, gxf_uid_t uid, const char* key,\n const char* value[], uint64_t length);\n// Sets a Float 64 1D-Vector parameter. Internally the data is stored in\n// a std::vector. The length of the vector should match the length of the registered parameter.\ngxf_result_t GxfParameterSet1DFloat64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n double* value, uint64_t length);\n// Sets a Float 64 2D-Vector parameter. Internally the data is stored in a\n// std::vector. The height should match the length of the outer std::vector\n// and the width should match the length of all the inner std::vectors. Also, these height and\n// width should match the shape of the registered parameters.\ngxf_result_t GxfParameterSet2DFloat64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n double** value, uint64_t height, uint64_t width);\n// Sets a signed 64-bit int 1D-Vector parameter. Internally the data is stored in\n// a std::vector. The length of the vector should match the length of the registered parameter.\ngxf_result_t GxfParameterSet1DInt64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n int64_t* value, uint64_t length);\n// Sets a signed 64-bit int 2D-Vector parameter. Internally the data is stored in a\n// std::vector. The height should match the length of the outer std::vector\n// and the width should match the length of all the inner std::vectors. Also, these height and\n// width should match the shape of the registered parameters.\ngxf_result_t GxfParameterSet2DInt64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n int64_t** value, uint64_t height, uint64_t width);\n// Sets a unsigned 64-bit unsigned int 1D-Vector parameter. Internally the data is stored in\n// a std::vector. The length of the vector should match the length of the registered parameter.\ngxf_result_t GxfParameterSet1DUInt64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t* value, uint64_t length);\n// Sets a unsigned 64-bit unsigned int 2D-Vector parameter. Internally the data is stored in a\n// std::vector. The height should match the length of the outer std::vector\n// and the width should match the length of all the inner std::vectors. Also, these height and\n// width should match the shape of the registered parameters.\ngxf_result_t GxfParameterSet2DUInt64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t** value, uint64_t height, uint64_t width);\n// Sets a signed 32-bit int 1-D Vector parameter. Internally the data is stored in\n// a std::vector. The length of the vector should match the length of the registered parameter.\ngxf_result_t GxfParameterSet1DInt32Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n int32_t* value, uint64_t length);\n// Sets a signed 32-bit int 2-D Vector parameter. Internally the data is stored in a\n// std::vector. The height should match the length of the outer std::vector\n// and the width should match the length of all the inner std::vectors. Also, these height and\n// width should match the shape of the registered parameters.\ngxf_result_t GxfParameterSet2DInt32Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n int32_t** value, uint64_t height, uint64_t width);\n\n// Sets a parameter from YAML. The YAML node pointer should be a type of 'YAML::Node*'.\ngxf_result_t GxfParameterSetFromYamlNode(gxf_context_t context, gxf_uid_t uid, const char* key,\n void* yaml_node, const char* prefix);\n\n// Sets a FilePath parameter\ngxf_result_t GxfParameterSetPath(gxf_context_t context, gxf_uid_t uid, const char* key,\n const char* value);\n\n// Gets a parameter as a YAML node. The YAML node pointer should be a type of 'YAML::Node*'.\ngxf_result_t GxfParameterGetAsYamlNode(gxf_context_t context, gxf_uid_t uid, const char* key,\n void* yaml_node);\n\n// Gets a 64-bit floating point parameter\ngxf_result_t GxfParameterGetFloat64(gxf_context_t context, gxf_uid_t uid, const char* key,\n double* value);\n// Gets a 32-bit floating point parameter\ngxf_result_t GxfParameterGetFloat32(gxf_context_t context, gxf_uid_t uid, const char* key,\n float* value);\n// Gets a 64-bit signed integer parameter\ngxf_result_t GxfParameterGetInt64(gxf_context_t context, gxf_uid_t uid, const char* key,\n int64_t* value);\n// Gets a 64-bit unsigned integer parameter\ngxf_result_t GxfParameterGetUInt64(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t* value);\n// Gets a 32-bit unsigned integer parameter\ngxf_result_t GxfParameterGetUInt32(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint32_t* value);\n// Gets a 16-bit unsigned integer parameter\ngxf_result_t GxfParameterGetUInt16(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint16_t* value);\n// Gets a string parameter\ngxf_result_t GxfParameterGetStr(gxf_context_t context, gxf_uid_t uid, const char* key,\n const char** value);\n// Gets a file path parameter\ngxf_result_t GxfParameterGetPath(gxf_context_t context, gxf_uid_t uid, const char* key,\n const char** value);\n// Gets a handle parameter\ngxf_result_t GxfParameterGetHandle(gxf_context_t context, gxf_uid_t uid, const char* key,\n gxf_uid_t* cid);\n// Gets a bool parameter\ngxf_result_t GxfParameterGetBool(gxf_context_t context, gxf_uid_t uid, const char* key,\n bool* value);\n// Gets a 32-bit signed integer parameter\ngxf_result_t GxfParameterGetInt32(gxf_context_t context, gxf_uid_t uid, const char* key,\n int32_t* value);\n// Gets the length of the 1D vector.\n// For 1D: rank = 1; shape = [length, ...]\ngxf_result_t GxfParameterGet1DFloat64VectorInfo(gxf_context_t context, gxf_uid_t uid,\n const char* key, uint64_t* length);\n// Gets the height/width of the 2D vector.\n// For 2D: rank = 2; shape = [height, width, ...]\ngxf_result_t GxfParameterGet2DFloat64VectorInfo(gxf_context_t context, gxf_uid_t uid,\n const char* key, uint64_t* height, uint64_t* width);\n// Gets the length of the 1D vector.\n// For 1D: rank = 1; shape = [length, ...]\ngxf_result_t GxfParameterGet1DInt64VectorInfo(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t* length);\n// Gets the height/width of the 2D vector.\n// For 2D: rank = 2; shape = [height, width, ...]\ngxf_result_t GxfParameterGet2DInt64VectorInfo(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t* height, uint64_t* width);\n// Gets the length of the 1D vector.\n// For 1D: rank = 1; shape = [length, ...]\ngxf_result_t GxfParameterGet1DUInt64VectorInfo(gxf_context_t context, gxf_uid_t uid,\n const char* key, uint64_t* length);\n// Gets the height/width of the 2D vector.\n// For 2D: rank = 2; shape = [height, width, ...]\ngxf_result_t GxfParameterGet2DUInt64VectorInfo(gxf_context_t context, gxf_uid_t uid,\n const char* key, uint64_t* height, uint64_t* width);\n// Gets the length of the 1D vector.\n// For 1D: rank = 1; shape = [length, ...]\ngxf_result_t GxfParameterGet1DInt32VectorInfo(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t* length);\n// Gets the height/width of the 2D vector.\n// For 2D: rank = 2; shape = [height, width, ...]\ngxf_result_t GxfParameterGet2DInt32VectorInfo(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t* height, uint64_t* width);\n// Gets a 1D-Vector of 64-bit floating point.\n// For 1D: rank = 1; shape = [length, ...]\n// The rank and shape should match with the internal registered std::vector parameter.\n// The length can be queried using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet1DFloat64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n double* value, uint64_t* length);\n// Gets a 1D-Vector of strings.\n// The length can be queried using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet1DStrVector(gxf_context_t context, gxf_uid_t uid, const char* key,\n char* value[], uint64_t* count, uint64_t* min_length);\n// Gets a 2D-Vector of 64-bit floating point.\n// For 2D: rank = 2; shape = [height, width, ...]\n// The rank and shape should match with the internal registered std::vector parameter.\n// The height and width can be obtained using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet2DFloat64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n double** value, uint64_t* height, uint64_t* width);\n// Gets a 1D-Vector of signed 64-bit integers.\n// For 1D: rank = 1; shape = [length, ...]\n// The rank and shape should match with the internal registered std::vector parameter.\n// The length can be queried using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet1DInt64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n int64_t* value, uint64_t* length);\n// Gets a 2D-Vector of signed 64-bit integers.\n// For 2D: rank = 2; shape = [height, width, ...]\n// The rank and shape should match with the internal registered std::vector parameter.\n// The height and width can be obtained using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet2DInt64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n int64_t** value, uint64_t* height, uint64_t* width);\n// Gets a 1D-Vector of unsigned 32-bit integers.\n// For 1D: rank = 1; shape = [length, ...]\n// The rank and shape should match with the internal registered std::vector parameter.\n// The length can be queried using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet1DUInt64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t* value, uint64_t* length);\n// Gets a 2D-Vector of unsigned 32-bit integers.\n// For 2D: rank = 2; shape = [height, width, ...]\n// The rank and shape should match with the internal registered std::vector parameter.\n// The height and width can be obtained using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet2DUInt64Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n uint64_t** value, uint64_t* height, uint64_t* width);\n// Gets a 1D-Vector of signed 32-bit integers.\n// For 1D: rank = 1; shape = [length, ...]\n// The rank and shape should match with the internal registered std::vector parameter.\n// The length can be queried using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet1DInt32Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n int32_t* value, uint64_t* length);\n// Gets a 2D-Vector of signed 32-bit integers.\n// For 2D: rank = 2; shape = [height, width, ...]\n// The rank and shape should match with the internal registered std::vector parameter.\n// The height and width can be obtained using GxfGetParameterInfo()\ngxf_result_t GxfParameterGet2DInt32Vector(gxf_context_t context, gxf_uid_t uid, const char* key,\n int32_t** value, uint64_t* height, uint64_t* width);\n// -- Graph execution ----------------------------------------------------------------------------\n\n// Loads a list of entities from a YAML file.\ngxf_result_t GxfGraphLoadFile(gxf_context_t context, const char* filename,\n const char* parameters_override[] = nullptr,\n const uint32_t num_overrides = 0);\n\n// Loads a list of entities from a YAML file. This API is used when shared context is created using\n// GxfGetSharedContext() and GxfContextCreateShared(). Separate instances of entities are created\n// for shared context by adding entity_prefix to the entity name.\ngxf_result_t GxfGraphLoadFileExtended(gxf_context_t context, const char* filename,\n const char* entity_prefix,\n const char* parameters_override[] = nullptr,\n const uint32_t num_overrides = 0,\n gxf_uid_t parent_eid = kNullUid,\n void* prerequisites = nullptr);\n\n// Saves a list of entities to a YAML file.\ngxf_result_t GxfGraphSaveToFile(gxf_context_t context, const char* filename);\n\n// Set the root folder for searching YAML files during loading\ngxf_result_t GxfGraphSetRootPath(gxf_context_t context, const char* path);\n\n// Loads a list of entities from a YAML file.\ngxf_result_t GxfGraphParseString(gxf_context_t context, const char* text,\n const char* parameters_override[] = nullptr,\n const uint32_t num_overrides = 0);\n\n// Activate all System components\ngxf_result_t GxfGraphActivate(gxf_context_t context);\n\n// Deactivate all System components\ngxf_result_t GxfGraphDeactivate(gxf_context_t context);\n\n// Starts the execution of the graph asynchronously\ngxf_result_t GxfGraphRunAsync(gxf_context_t context);\n\n// Interrupt the execution of the graph\ngxf_result_t GxfGraphInterrupt(gxf_context_t context);\n\n// Waits for the graph to complete execution\ngxf_result_t GxfGraphWait(gxf_context_t context);\n\n// Runs all System components and waits for their completion\ngxf_result_t GxfGraphRun(gxf_context_t context);\n\n// -- Info queries -------------------------------------------------------------------------------\n\n// Type to represent version of GXF Runtime and list of loaded Extensions\ntypedef struct {\n const char* version; // GXF Runtime Version\n uint64_t num_extensions; // in-out capacity of extensions/Number of extension types\n gxf_tid_t* extensions; // List of Extension IDs\n} gxf_runtime_info;\n\n// Gets Meta Data about the GXF Runtime\ngxf_result_t GxfRuntimeInfo(gxf_context_t context, gxf_runtime_info* info);\n\n// Type to represent description and list of components for loaded Extension\ntypedef struct {\n gxf_tid_t id; // (UUID) Extension ID (registered via GXF_EXT_FACTORY_SET_INFO)\n const char* name; // (String) Extension Name (registered via GXF_EXT_FACTORY_SET_INFO)\n const char* description; // (String) Description (registered via GXF_EXT_FACTORY_SET_INFO)\n const char* version; // (String) Extension Version (registered via GXF_EXT_FACTORY_SET_INFO)\n const char* runtime_version;\n // (String) GXF Core version with which the extension was compiled with\n const char* license; // (String) Extension License (registered via GXF_EXT_FACTORY_SET_INFO)\n const char* author; // (String) Extension Author (registered via GXF_EXT_FACTORY_SET_INFO)\n const char* display_name;\n // (String) Extension Display Name (registered via\n // GXF_EXT_FACTORY_SET_DISPLAY_INFO, maximum 30 characters)\n const char* category; // (String) Extension Category (registered via\n // GXF_EXT_FACTORY_SET_DISPLAY_INFO, maximum 30 characters)\n const char* brief; // (String) Extension Brief (registered via\n // GXF_EXT_FACTORY_SET_DISPLAY_INFO, maximum 50 characters)\n uint64_t num_components; // in-out capacity of components/Number of components\n gxf_tid_t* components; // List of IDs of provided components\n} gxf_extension_info_t;\n\n// Gets description and list of components in loaded Extension\ngxf_result_t GxfExtensionInfo(gxf_context_t context, gxf_tid_t tid, gxf_extension_info_t* info);\n\n// Type to represent description and list of Parameter of Component\ntypedef struct {\n gxf_tid_t cid; // (UUID) Component ID (registered via GXF_EXT_FACTORY_ADD)\n const char* base_name; // (String) Base Class Name (registered via GXF_EXT_FACTORY_ADD)\n int is_abstract; // (Bool) If the Component is abstract (Can not be instantiated)\n const char* type_name; // (String) Component Name (registered via GXF_EXT_FACTORY_ADD)\n const char* display_name;\n // (String) Extension Display Name (registered via\n // GXF_EXT_FACTORY_SET_DISPLAY_INFO, maximum 30 characters)\n const char* brief; // (String) Extension Brief (registered via\n // GXF_EXT_FACTORY_SET_DISPLAY_INFO, maximum 50 characters)\n const char* description; // (String) Description (registered via GXF_EXT_FACTORY_ADD)\n uint64_t num_parameters; // in-out capacity of parameters/Number of Parameters\n const char** parameters; // List of Names for Parameters\n} gxf_component_info_t;\n\n// Gets description and list of parameters of Component. Parameters are only available after\n// at least one instance is created for the Component.\ngxf_result_t GxfComponentInfo(gxf_context_t context, gxf_tid_t tid, gxf_component_info_t* info);\n\n/// @brief The type of a parameter\ntypedef enum {\n GXF_PARAMETER_TYPE_CUSTOM = 0, // A custom type not natively supported by GXF.\n GXF_PARAMETER_TYPE_HANDLE = 1, // A GXF handle. The handle type is specified separately.\n GXF_PARAMETER_TYPE_STRING = 2, // A null-terminated character string (const char*)\n GXF_PARAMETER_TYPE_INT64 = 3, // A 64-bit signed integer (int64_t)\n GXF_PARAMETER_TYPE_UINT64 = 4, // A 64-bit unsigned integer (uint64_t)\n GXF_PARAMETER_TYPE_FLOAT64 = 5, // A 64-bit floating point (double)\n GXF_PARAMETER_TYPE_BOOL = 6, // A boolean type (bool)\n GXF_PARAMETER_TYPE_INT32 = 7, // A 32-bit signed integer (int32_t)\n GXF_PARAMETER_TYPE_FILE = 8, // a file system path (string)\n GXF_PARAMETER_TYPE_INT8 = 9, // A 8-bit signed integer (int8_t)\n GXF_PARAMETER_TYPE_INT16 = 10, // A 16-bit signed integer (int16_t)\n GXF_PARAMETER_TYPE_UINT8 = 11, // A 8-bit unsigned integer (uint8_t)\n GXF_PARAMETER_TYPE_UINT16 = 12, // A 16-bit unsigned integer (uint16_t)\n GXF_PARAMETER_TYPE_UINT32 = 13, // A 32-bit unsigned integer (uint32_t)\n GXF_PARAMETER_TYPE_FLOAT32 = 14, // A 32-bit floating point (float)\n GXF_PARAMETER_TYPE_COMPLEX64 = 15, // A 64-bit complex floating point (float)\n GXF_PARAMETER_TYPE_COMPLEX128 = 16, // A 128-bit complex floating point (double)\n} gxf_parameter_type_t;\n\n// Holds metadata information about a parameter which was registered as part of the component\n// interface.\ntypedef struct {\n const char* key; // The name of the parameter as it appears in the GXF file.\n const char* headline; // A short headline used to display the parameter to a human.\n const char* description; // A longer text describing the usage of the parameter.\n gxf_parameter_flags_t flags; // Parameter flags for example to make a parameter optional.\n gxf_parameter_type_t type; // The type of the parameter\n gxf_tid_t handle_tid; // In case the parameter is a handle the TID of the component.\n const void* default_value; // Default value of parameter, N/A for handle and custom params\n const void* numeric_min; // Min value of range for numeric parameters, N/A for other types\n const void* numeric_max; // Max value of range for numeric parameters, N/A for other types\n const void* numeric_step; // Step value of range for numeric parameters, N/A for other types\n const char* platform_information;\n // (String) Platforms separated by comma. Empty means all platforms\n int32_t rank; // Rank of the parameter. 0-scalar, 1-list etc. Max rank is 8\n int32_t shape[8]; // Sizes of multi dimensional parameters if it is of fixed\n // length(array). Shape of a dimension is -1 for scalar and\n // variable length arrays(vector)\n} gxf_parameter_info_t;\n\n// Gives a string describing the parameter type\nconst char* GxfParameterTypeStr(gxf_parameter_type_t param_type);\n\n// Gives a string describing the flag type\nconst char* GxfParameterFlagTypeStr(gxf_parameter_flags_t_ flag_type);\n\n// Gets description of specific parameter. Fail if the component is not instantiated yet.\ngxf_result_t GxfParameterInfo(gxf_context_t context, gxf_tid_t cid, const char* key,\n gxf_parameter_info_t* info);\n\ngxf_result_t GxfGetParameterInfo(gxf_context_t context, gxf_tid_t cid, const char* key,\n gxf_parameter_info_t* info);\n\ngxf_result_t GxfRedirectLog(gxf_context_t context, FILE* fp);\n\n// -------------------------------------------------------------------------------------------------\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#ifdef __cplusplus\n\ninline bool operator==(const gxf_tid_t& lhs, const gxf_tid_t& rhs) noexcept {\n return lhs.hash1 == rhs.hash1 && lhs.hash2 == rhs.hash2;\n}\n\ninline bool operator!=(const gxf_tid_t& lhs, const gxf_tid_t& rhs) noexcept {\n return lhs.hash1 != rhs.hash1 || lhs.hash2 != rhs.hash2;\n}\n\ninline bool operator<(const gxf_tid_t& lhs, const gxf_tid_t& rhs) noexcept {\n return lhs.hash1 < rhs.hash1 || (lhs.hash1 == rhs.hash1 && lhs.hash2 < rhs.hash2);\n}\n\n#endif\n\n#endif // NVIDIA_GXF_CORE_GXF_H_\n\n// Include the extended API functions.\n#include \"gxf_ext.h\"\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/gxf_ext.h", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_GXF_EXT_H_\n#define NVIDIA_GXF_CORE_GXF_EXT_H_\n\n#ifdef __cplusplus\n#include \n#else\n#include \n#endif\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n// -------------------------------------------------------------------------------------------------\n\n/// @brief GXF bitmasks\ntypedef uint32_t GxfFlags;\n\n// -------------------------------------------------------------------------------------------------\n\n/// @brief Structure specifying parameters for loading extensions\ntypedef struct {\n // Optional list of extension filenames to load\n const char* const* extension_filenames;\n // The number of extensions to load\n uint32_t extension_filenames_count;\n // Optional list of manifest filenames to load\n const char* const* manifest_filenames;\n // The number of manifests to load\n uint32_t manifest_filenames_count;\n // An optional base directory which is prepended to all extensions filenames, including those\n // loaded via manifests.\n const char* base_directory;\n} GxfLoadExtensionsInfo;\n\n/// @brief Loads GXF extension libraries\n///\n/// Loads one or more extensions either directly by their filename or indirectly by loading\n/// manifest files. Before a component can be added to a GXF entity the GXF extension shared\n/// library providing the component must be loaded. An extensions must only be loaded once.\n///\n/// To simplify loading multiple extensions at once the developer can create a manifest file which\n/// lists all extensions he needs. This function will then load all extensions listed in the\n/// manifest file. Multiple manifest may be loaded, however each extensions may still be loaded\n/// only a single time.\n///\n/// A manifest file is a YAML file with a single top-level entry 'extensions' followed by a\n/// list of filenames of GXF extension shared libraries.\n///\n/// Example:\n/// ----- START OF FILE -----\n/// extensions:\n/// - gxf/std/libgxf_std.so\n/// - gxf/npp/libgxf_npp.so\n/// ----- END OF FILE -----\n///\n/// @param context is the GXF context in which to load extensions\n/// @param info is a pointer to a GxfLoadExtensionsInfo structure describing parameters for loading\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfLoadExtensions(gxf_context_t context, const GxfLoadExtensionsInfo* info);\n\n/// @brief Loads a metadata file generated by the GXF registry\n///\n/// The GXF registry tool generates a metadata file of the contents of an extension during\n/// registration. These metadata files can be used to resolve typename and TID's of components for\n/// other extensions which depend on them. metadata files do not contain the actual implementation\n/// of the extension and must be loaded only to run the extension query API's on extension\n/// libraries which have the actual implementation and only depend on the metadata for type\n/// resolution.\n///\n/// If some components of extension B depend on some components in extension A:\n/// - Load metadata file for extension A\n/// - Load extension library for extension B using 'GxfLoadExtensions'\n/// - Run extension query api's on extension B and it's components.\n///\n/// @param context A valid GXF context\n/// @param filenames absolute paths of metadata files generated by the registry during\n/// extension registration\n/// @param count The number of metadata files to be loaded\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfLoadExtensionMetadataFiles(gxf_context_t context, const char* const* filenames,\n uint32_t count);\n\n// -------------------------------------------------------------------------------------------------\n\n/// @brief Bitmask specifying storage mode for an entity\ntypedef enum GxfEntityCreateFlagBits {\n // 'GXF_ENTITY_CREATE_PROGRAM_BIT' specifies that the entity will be added to the program\n // entities. Program entities are kept alive for the duration of the program. They are activated\n // automatically when the program is activated and deactivated when the program is deactivated.\n // If the program was already activated when the entity is created the entity must still be\n // activated manually.\n GXF_ENTITY_CREATE_PROGRAM_BIT = 0x00000001\n} GxfEntityCreateFlagBits;\n\n/// @brief Bitmask of GxfEntityCreateFlagBits\ntypedef GxfFlags GxfEntityCreateFlags;\n\n/// @brief Structure specifying parameters for creating entities\ntypedef struct {\n // 'entity_name' is the name of the entity which is created. If this is a nullptr an undefined\n // unique name is chosen. The name must not start with a double underscore.\n const char* entity_name;\n // 'flags' is a bitmask of GxfEntityCreateFlagsBits indicating storage method and usage behavior\n // for the created entity.\n GxfEntityCreateFlags flags;\n} GxfEntityCreateInfo;\n\n/// @brief Create a new GXF entity\n///\n/// Entities are light-weight containers to hold components and form the basic building blocks\n/// of a GXF application. Entities are created when a GXF file is loaded, or they can be created\n/// manually using this function. Entities created with this function must be destroyed using\n/// 'GxfEntityDestroy'. After the entity was created components can be added to it with\n/// 'GxfComponentAdd'. To start execution of codelets on an entity the entity needs to be\n/// activated first. This can happen automatically using 'GXF_ENTITY_CREATE_PROGRAM_BIT' or\n/// manually using 'GxfEntityActivate'.\n///\n/// @param context is the GXF context that creates the entity.\n/// @param info is a pointer to a GxfEntityCreateInfo structure containing parameters affecting\n/// the creation of the entity.\n/// @param eid is a pointer to a gxf_uid_t handle in which the resulting entity is returned.\n/// @return On success the function returns GXF_SUCCESS.\ngxf_result_t GxfCreateEntity(gxf_context_t context, const GxfEntityCreateInfo* info,\n gxf_uid_t* eid);\n\n\n/// @brief Create a new GXF entity and return the entity item ptr\n///\n/// Entities are light-weight containers to hold components and form the basic building blocks\n/// of a GXF application. Entities are created when a GXF file is loaded, or they can be created\n/// manually using this function. Entities created with this function must be destroyed using\n/// 'GxfEntityDestroy'. After the entity was created components can be added to it with\n/// 'GxfComponentAdd'. To start execution of codelets on an entity the entity needs to be\n/// activated first. This can happen automatically using 'GXF_ENTITY_CREATE_PROGRAM_BIT' or\n/// manually using 'GxfEntityActivate'. This function also returns the pointer entity item\n/// which can be used to create C++ nvidia::gxf::Entity type objects.\n///\n/// @param context is the GXF context that creates the entity.\n/// @param info is a pointer to a GxfEntityCreateInfo structure containing parameters affecting\n/// the creation of the entity.\n/// @param eid is a pointer to a gxf_uid_t handle in which the resulting entity is returned.\n/// @param item_ptr is a pointer to pointer to entity item which is created\n/// @return On success the function returns GXF_SUCCESS.\ngxf_result_t GxfCreateEntityAndGetItem(gxf_context_t context, const GxfEntityCreateInfo* info,\n gxf_uid_t* eid, void** item_ptr);\n// -------------------------------------------------------------------------------------------------\n/// @brief Name of default EntityGroup\n#define kDefaultEntityGroupName \"default_entity_group\"\n\n/// @brief Create a new GXF EntityGroup\n///\n/// EntityGroup is a group of EntityItems, such that these entities are bonded to some\n/// common properties. For now the common property is all kinds of resources.\n///\n/// @param context A valid GXF context\n/// @param name name to create the EntityGroup\n/// @param gid returned uid for the created EntityGroup, abbreviation for group id.\n/// @return GXF error code\ngxf_result_t GxfCreateEntityGroup(gxf_context_t context, const char* name, gxf_uid_t* gid);\n\n/// @brief Add an entity eid into an EntityGroup by EntityGroup uid\n///\n/// Each EntityItem is created with default EntityGroup uid, this API\n/// 1. updates EntityGroup uid in current EntityItem, to new group id gid;\n/// 2. Remove eid from its previous EntityGroup;\n/// 3. add eid to its new EntityGroup\n///\n/// @param context A valid GXF context\n/// @param gid UID of an existing (new) EntityGroup\n/// @param eid The unique object ID (UID) of a valid entity\n/// @return GXF error code\ngxf_result_t GxfUpdateEntityGroup(gxf_context_t context, gxf_uid_t gid, gxf_uid_t eid);\n\n/// @brief Check if an entity id is valid currently in GXF runtime\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity to check\n/// @param valid returned boolean indicating if the entity is valid in Gxf runtime(warden)\n/// @return GXF error code\ngxf_result_t GxfEntityIsValid(gxf_context_t context, gxf_uid_t eid, bool* valid);\n\n/// @brief Finds and returns all resource component cids for EntityGroup pointed by eid\n///\n/// Finds and returns all resource component cids for EntityGroup pointed by eid.\n/// If more than `max_entities` exist only `max_entities` will be returned.\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @param num_resource_cids In/Out: the max number of components that can fit in\n/// the buffer/the number of resources in eid's EntityGroup\n/// @param resource_cids A buffer allocated by the caller for returned UIDs of all resources, with\n/// capacity for `num_resource_cids`.\n/// @return GXF_SUCCESS if the operation was successful, GXF_QUERY_NOT_ENOUGH_CAPACITY if more\n/// resources exist in eid's EntityGroup, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityGroupFindResources(gxf_context_t context, gxf_uid_t eid,\n uint64_t* num_resource_cids, gxf_uid_t* resource_cids);\n\n/// @brief Find the EntityGroup gid that the entity belongs to\n///\n/// EntityGroup is a group of EntityItems, such that these entities are bonded to some\n/// common properties. For now the common property is all kinds of resources. Through\n/// life time of each entity, it always corresponds to an EntityGroup. Eg, newly created\n/// EntityItem points to Default EntityGroup, and user can update its EntityGroup to valid\n/// one only.\n///\n/// @param context A valid GXF context\n/// @param eid eid of an EntityItem, whose EntityGroup id field is used find EntityGroup name\n/// @param gid The returned id of the entity group.\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityGroupId(gxf_context_t context, gxf_uid_t eid, gxf_uid_t* gid);\n\n/// @brief Find name of EntityGroup that holds the entity\n///\n/// EntityGroup is a group of EntityItems, such that these entities are bonded to some\n/// common properties. For now the common property is all kinds of resources. Through\n/// life time of each entity, it always corresponds to an EntityGroup. Eg, newly created\n/// EntityItem points to Default EntityGroup, and user can update its EntityGroup to valid\n/// one only.\n///\n/// @param context A valid GXF context\n/// @param eid eid of an EntityItem, whose EntityGroup id field is used find EntityGroup name\n/// @param name The returned name of the EntityGroup\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityGroupName(gxf_context_t context, gxf_uid_t eid, const char** name);\n\n/// @brief Gets cid of a resource component that is grouped with the given entity\n///\n/// @param context A valid GXF context\n/// @param eid The unique object ID (UID) of a valid entity\n/// @param type The fully qualified C++ type name of the component\n/// @param resource_key the key or name of the resource\n/// @param resource_cid The returned cid of the resource component\n/// @return GXF_SUCCESS if the operation was successful, or otherwise one of the GXF error codes.\ngxf_result_t GxfEntityResourceGetHandle(gxf_context_t context, gxf_uid_t eid,\n const char* type, const char* resource_key, gxf_uid_t* resource_cid);\n// -------------------------------------------------------------------------------------------------\n\n/// @brief Severity levels for GXF_LOG_* logging macros\ntypedef enum {\n GXF_SEVERITY_NONE = 0,\n GXF_SEVERITY_ERROR = 1,\n GXF_SEVERITY_WARNING = 2,\n GXF_SEVERITY_INFO = 3,\n GXF_SEVERITY_DEBUG = 4,\n GXF_SEVERITY_VERBOSE = 5,\n} gxf_severity_t;\n\n/// @brief Sets the severity level of the logs (corresponding to GXF_LOG_* logging macros) for the\n/// entire application\n///\n/// @param context a valid GXF context\n/// @param severity a valid severity level as defined in `gxf_severity_t`. Logs corresponding to\n/// any level <= severity will be logged.\n/// @return On success the function returns GXF_SUCCESS.\n///\ngxf_result_t GxfSetSeverity(gxf_context_t context, gxf_severity_t severity);\n\n/// @brief Returns the current severity level of the logs.\n///\n/// @param context a valid GXF context\n/// @param severity a pointer to a gxf_severity_t in which the resulting severity is returned.\n/// @return On success the function returns GXF_SUCCESS.\n///\ngxf_result_t GxfGetSeverity(gxf_context_t context, gxf_severity_t* severity);\n\n// -------------------------------------------------------------------------------------------------\n\n/// @brief Simple macro to convert enum values to their string representations which can be\n/// useful for logging enum types\n#define GXF_ENUM_TO_STR(X, Y) \\\n case X: \\\n return #Y;\n\n\n#ifdef __cplusplus\n} // extern \"C\"\n#endif\n\n#endif // NVIDIA_GXF_CORE_GXF_EXT_H_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/handle.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_HANDLE_HPP\n#define NVIDIA_GXF_CORE_HANDLE_HPP\n\n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"common/type_name.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A handle which gives access to a component without specifying its type.\nclass UntypedHandle {\n public:\n UntypedHandle(const UntypedHandle& component) = default;\n UntypedHandle(UntypedHandle&& component) = default;\n UntypedHandle& operator=(const UntypedHandle& component) = default;\n UntypedHandle& operator=(UntypedHandle&& component) = default;\n\n // Creates a null untyped handle\n static UntypedHandle Null() {\n return UntypedHandle{kNullContext, kNullUid};\n }\n\n // Creates a new untyped handle\n static Expected Create(gxf_context_t context, gxf_uid_t cid) {\n UntypedHandle untyped_handle{context, cid};\n gxf_tid_t tid;\n gxf_result_t code = GxfComponentType(context, cid, &tid);\n if (code != GXF_SUCCESS) {\n return Unexpected{code};\n }\n const auto result = untyped_handle.initialize(tid);\n if (!result) {\n return ForwardError(result);\n }\n return untyped_handle;\n }\n\n // Creates a new untyped handle with component pointer\n static Expected Create(gxf_context_t context, gxf_uid_t cid,\n gxf_tid_t tid, void* ptr) {\n return UntypedHandle{context, cid, tid, ptr};\n }\n\n // The context to which the component belongs\n gxf_context_t context() const { return context_; }\n // The ID of the component.\n gxf_uid_t cid() const { return cid_; }\n // The type ID describing the component type.\n gxf_tid_t tid() const { return tid_; }\n // Get the pointer to underlying component object\n void* get_ptr() const {return pointer_;}\n // Returns null if the handle is equivalent to a nullptr.\n bool is_null() const {\n return context_ == kNullContext || cid_ == kNullUid || pointer_ == nullptr;\n }\n // Same as 'is_null'.\n explicit operator bool() const { return !is_null(); }\n // The component name\n const char* name() const {\n const char* result;\n const gxf_result_t code = GxfComponentName(context(), cid(), &result);\n return (code == GXF_SUCCESS) ? result : \"\";\n }\n\n protected:\n UntypedHandle(gxf_context_t context, gxf_uid_t cid)\n : context_{context}, cid_{cid}, tid_{GxfTidNull()}, pointer_{nullptr} { }\n\n UntypedHandle(gxf_context_t context, gxf_uid_t cid, gxf_tid_t tid, void* pointer)\n : context_{context}, cid_{cid}, tid_{tid}, pointer_{pointer} {}\n\n Expected initialize(gxf_tid_t tid) {\n tid_ = tid;\n if (pointer_ == nullptr) {\n return ExpectedOrCode(GxfComponentPointer(context_, cid_, tid_, &pointer_));\n }\n return Success;\n }\n\n Expected initialize(const char* type_name) {\n gxf_tid_t tid;\n gxf_result_t code = GxfComponentTypeId(context_, type_name, &tid);\n if (code != GXF_SUCCESS) {\n return Unexpected{code};\n }\n return initialize(tid);\n }\n\n Expected verifyPointer() const {\n if (pointer_ == nullptr) {\n GXF_LOG_ERROR(\"Handle pointer is null for component %s - id %ld\", name(), cid());\n return Unexpected{GXF_FAILURE};\n }\n void* raw_pointer;\n auto result = GxfComponentPointer(context(), cid(), tid_, &raw_pointer);\n if (result != GXF_SUCCESS) {\n return Unexpected{result};\n }\n if (raw_pointer != pointer_) {\n GXF_LOG_ERROR(\"Handle pointers do not match for component %s: %p vs %p\",\n name(), raw_pointer, pointer_);\n return Unexpected{GXF_FAILURE};\n }\n return Success;\n }\n\n gxf_context_t context_;\n gxf_uid_t cid_;\n gxf_tid_t tid_;\n void* pointer_;\n};\n\n// A handle which gives access to a component with a specific type.\ntemplate \nclass Handle : public UntypedHandle {\n public:\n // Creates a null handle\n static Handle Null() {\n return Handle{};\n }\n\n // An unspecified handle is a unique handle used to denote a component which\n // will be created in the future. A parameter of Handle to a type does not consider\n // \"Unspecified\" as a valid parameter value and hence this handle must only be used\n // when defining a graph application across different files and the parameters are set\n // in a delayed fashion (sub-graphs and parameter yaml files for example)\n // Entity activation will fail if any of the mandatory parameters are \"Unspecified\"\n static Handle Unspecified() {\n return Handle(kNullContext, kUnspecifiedUid);\n }\n\n // Creates a new handle\n static Expected Create(gxf_context_t context, gxf_uid_t cid) {\n Handle handle{context, cid};\n const auto result = handle.initialize(TypenameAsString());\n if (!result) {\n return ForwardError(result);\n }\n return handle;\n }\n\n static Expected Create(gxf_context_t context, gxf_uid_t cid,\n gxf_tid_t tid, void * ptr) {\n if (GxfTidIsNull(tid) || ptr == nullptr) {\n return Create(context, cid);\n }\n Handle handle{context, cid, tid, ptr};\n return handle;\n }\n\n // Creates a new handle from an untyped handle\n static Expected Create(const UntypedHandle& untyped_handle) {\n return Create(untyped_handle.context(), untyped_handle.cid(),\n untyped_handle.tid(), untyped_handle.get_ptr());\n }\n\n friend bool operator==(const Handle& lhs, const Handle& rhs) {\n return lhs.context() == rhs.context() && lhs.cid() == rhs.cid();\n }\n\n friend bool operator!=(const Handle& lhs, const Handle& rhs) {\n return lhs.context() != rhs.context() || lhs.cid() != rhs.cid();\n }\n\n friend bool operator<(const Handle& lhs, const Handle& rhs) {\n return lhs.cid() < rhs.cid();\n }\n\n Handle(gxf_context_t context = kNullContext, gxf_uid_t uid = kNullUid)\n : UntypedHandle{context, uid} {}\n\n Handle(gxf_context_t context , gxf_uid_t uid , gxf_tid_t tid, void* ptr)\n : UntypedHandle{context, uid, tid, ptr} {}\n\n ~Handle() = default;\n\n Handle(const Handle& component) = default;\n Handle(Handle&& component) = default;\n Handle& operator=(const Handle& component) = default;\n Handle& operator=(Handle&& component) = default;\n\n template \n Handle(const Handle& derived) : UntypedHandle(derived) {\n static_assert(std::is_base_of::value,\n \"Handle conversion is only allowed from derived class to base class\");\n }\n\n // Allow conversion from handle to pointer\n operator T*() const { return get(); }\n\n T* operator->() const {\n return get();\n }\n\n T* get() const {\n // Verifying the pointer every time the handle is accessed causes a\n // significant bottle neck in perf. This should be removed in a future\n // release. Uncomment below line if there is any problem.\n // GXF_ASSERT(verifyPointer(), \"Invalid Component Pointer.\");\n GXF_ASSERT_FALSE(pointer_ == nullptr);\n return reinterpret_cast(pointer_);\n }\n\n Expected try_get() const {\n // Verifying the pointer every time the handle is accessed causes a\n // significant bottle neck in perf. This should be removed in a future\n // release. Uncomment below line if there is any problem.\n // if (!verifyPointer()) { return Unexpected{GXF_FAILURE}; }\n if (pointer_ == nullptr) { return Unexpected{GXF_FAILURE}; }\n return reinterpret_cast(pointer_);\n }\n\n private:\n using UntypedHandle::UntypedHandle;\n};\n\n\n// Creates a new handle given the string representation of the handle in a yaml blob\n// If the value is of format / then cid is ignored.\n// If the entity name is not specified, the value indicates just the component name, then\n// 'cid' is used to query the entity name to create the handle\ntemplate \nstatic Expected> CreateHandleFromString(gxf_context_t context, gxf_uid_t cid,\n const char* value) {\n gxf_uid_t eid;\n std::string component_name;\n const std::string tag{value};\n const size_t pos = tag.find('/');\n\n if (pos == std::string::npos) {\n // Get the entity of this component\n auto result = GxfComponentEntity(context, cid, &eid);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Failed to find entity for component [C%05\" PRId64 \"] with name [%s] with\"\n \" error %s\", cid, value, GxfResultStr(result));\n return Unexpected{result};\n }\n component_name = tag;\n } else {\n // Split the tag into entity and component name\n const std::string entity_name = tag.substr(0, pos);\n component_name = tag.substr(pos + 1);\n // Search for the entity\n auto result = GxfEntityFind(context, entity_name.c_str(), &eid);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Failed to find entity [E%05\" PRId64 \"] with name [%s] while parsing '%s'\",\n eid, entity_name.c_str(), tag.c_str());\n return Unexpected{result};\n }\n }\n\n // Get the type id of the component we are are looking for.\n gxf_tid_t tid;\n auto result = GxfComponentTypeId(context, TypenameAsString(), &tid);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Failed to find type ID of component type [%s] with error %s\",\n TypenameAsString(), GxfResultStr(result));\n return Unexpected{result};\n }\n\n gxf_uid_t cid2;\n // Find the component in the indicated entity\n result = GxfComponentFind(context, eid, tid, component_name.c_str(), nullptr, &cid2);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Failed to find component in entity [E%05\" PRId64 \"] with name [%s]\",\n eid, component_name.c_str());\n return Unexpected{result};\n }\n\n return Handle::Create(context, cid2);\n}\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_PARAMETER_HPP_\n#define NVIDIA_GXF_CORE_PARAMETER_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/core/parameter_parser.hpp\"\n#include \"gxf/core/parameter_wrapper.hpp\"\n\n\nnamespace nvidia {\nnamespace gxf {\n\n// Base class for parameters stored in ParameterStorage\nclass ParameterBackendBase {\n public:\n virtual ~ParameterBackendBase() = default;\n\n // The context to which this parameter backend belongs\n gxf_context_t context() const { return context_; }\n\n // The object to which this parameter is attached.\n gxf_uid_t uid() const { return uid_; }\n\n // The name of the parameter\n const char* key() const { return key_; }\n\n // Returns true if the parameter is guaranteed to always have a value set. Only mandatory\n // parameters can be accessed directly with 'get' instead of using 'try_get'.\n bool isMandatory() const { return (flags_ & GXF_PARAMETER_FLAGS_OPTIONAL) == 0; }\n\n // Returns true if the parameter can not be changed after the component has been activated.\n bool isConstant() const { return (flags_ & GXF_PARAMETER_FLAGS_DYNAMIC) == 0; }\n\n // Sets the latest value from the backend to the frontend.\n virtual void writeToFrontend() = 0;\n\n // Parses the parameter from the given YAML object.\n virtual Expected parse(const YAML::Node& node, const std::string& prefix) = 0;\n\n // Wrap the parameter as a YAML node.\n virtual Expected wrap() = 0;\n\n // Returns true if the parameter is set\n virtual bool isAvailable() const = 0;\n\n // Returns true if it is possible to change this parameter\n bool isImmutable() const {\n if (isConstant()) {\n const bool is_active = false; // FIXME(v1) Check that component is not active.\n if (is_active) {\n return true;\n }\n }\n return false;\n }\n\n // FIXME(v1) make private\n gxf_context_t context_{nullptr};\n gxf_uid_t uid_{kNullUid};\n gxf_parameter_flags_t flags_{0};\n bool is_dynamic_{false};\n const char* key_{nullptr};\n const char* headline_{nullptr};\n const char* description_{nullptr};\n};\n\ntemplate \nclass Parameter;\n\n// This class stores a parameter of a specific type in the backend.\ntemplate \nclass ParameterBackend : public ParameterBackendBase {\n public:\n void writeToFrontend() override;\n Expected parse(const YAML::Node& node, const std::string& prefix) override;\n bool isAvailable() const override { return value_.has_value(); }\n\n // Sets the parameter to the given value.\n Expected set(T value) {\n // Make sure that the new value passes the validator\n if (validator_&& !validator_(value)) { return Unexpected{GXF_PARAMETER_OUT_OF_RANGE}; }\n // Don't allow modification of a parameter which is currently immutable\n if (isImmutable()) { return Unexpected{GXF_PARAMETER_CAN_NOT_MODIFY_CONSTANT}; }\n // Update the parameter value\n value_ = std::move(value);\n return Success;\n }\n\n Expected wrap() {\n if (!value_) {\n return Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n }\n return ParameterWrapper::Wrap(context(), value_.value());\n }\n\n // Gets the current value of the parameter.\n const Expected& try_get() const { return value_; }\n\n // FIXME(v1) make private\n nvidia::gxf::Parameter* frontend_ = nullptr;\n std::function validator_;\n Expected value_ = Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n};\n\n// An intermediate base class for parameters which store a handle.\nclass HandleParameterBackend : public ParameterBackendBase {\n public:\n virtual ~HandleParameterBackend() = default;\n\n // Gets the component ID of the handle.\n virtual Expected get() const = 0;\n\n // Sets the handle using just a component ID\n virtual Expected set(gxf_uid_t cid) = 0;\n};\n\n// A specialization of ParameterBackend for handle types. It derives from the intermediate base\n// class HandleParameterBackend so that parameter backends of handle types all have a common base\n// class.\ntemplate \nclass ParameterBackend> : public HandleParameterBackend {\n public:\n void writeToFrontend() override;\n Expected parse(const YAML::Node& node, const std::string& prefix) override;\n bool isAvailable() const override {\n return (value_.has_value()) && (value_ != Handle::Unspecified());\n }\n\n Expected wrap() {\n if (!value_ || value_ == Handle::Unspecified()) {\n return Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n }\n\n return ParameterWrapper>::Wrap(context(), value_.value());\n }\n\n // Sets the handle using just a component ID\n Expected set(gxf_uid_t cid) override {\n auto expected = Handle::Create(context(), cid);\n if (expected) {\n value_ = expected.value();\n return Success;\n } else {\n return ForwardError(expected);\n }\n }\n\n // Gets the component ID of the handle.\n Expected get() const override {\n if (!value_) {\n GXF_LOG_VERBOSE(\"Handle parameter with name '%s' is not initialized\", key());\n return Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n } else if (value_ == Handle::Unspecified()) {\n GXF_LOG_VERBOSE(\"Handle parameter with name '%s' is unspecified\", key());\n return Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n }\n return value_->cid();\n }\n\n // Sets the parameter to the given value.\n Expected set(Handle value) {\n if (isImmutable()) { return Unexpected{GXF_PARAMETER_CAN_NOT_MODIFY_CONSTANT}; }\n value_ = std::move(value);\n return Success;\n }\n\n // Gets the current value of the parameter, return Unexpected if not\n // set or if it's set to Handle::Unspecified()\n const Expected>& try_get() const {\n if (value_ == Handle::Unspecified()) { return unspecified_handle_; }\n return value_;\n }\n\n // FIXME(v1) make private\n const Expected> unspecified_handle_ = Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n nvidia::gxf::Parameter>* frontend_ = nullptr;\n Expected> value_ = Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n};\n\n\n// Common base class for specializations of Parameter.\nclass ParameterBase {\n public:\n virtual ~ParameterBase() = default;\n};\n\n// This type represents a parameter of a component and can be used in custom components. It\n// communicates with the backend to set and get parameters as configured.\ntemplate \nclass Parameter : public ParameterBase {\n public:\n Parameter() = default;\n\n // enable copying\n Parameter(const Parameter& other)\n : mutex_() {\n std::unique_lock lock(other.mutex_);\n value_ = other.value_;\n backend_ = other.backend_;\n }\n // Gets the current parameter value. Only valid if the parameter is marked as 'mandatory' in the\n // parameter interface. Otherwise an assert will be raised.\n const T& get() const {\n std::unique_lock lock(mutex_);\n GXF_ASSERT(backend_ != nullptr, \"A parameter with type '%s' was not registered.\",\n TypenameAsString());\n GXF_ASSERT(backend_->isMandatory(), \"Only mandatory parameters can be accessed with get(). \"\n \"'%s' is not marked as mandatory\", backend_->key());\n GXF_ASSERT(value_, \"Mandatory parameter '%s' was not set.\", backend_->key());\n return value_.value();\n }\n\n // Convenience function for accessing a mandatory parameter.\n operator const T&() const {\n return get();\n }\n\n // Tries to get the parameter value. If the parameter is not set Unexpected is returned.\n const Expected& try_get() const {\n std::unique_lock lock(mutex_);\n return value_;\n }\n\n // Sets the parameter to the given value.\n Expected set(T value) {\n GXF_ASSERT(backend_ != nullptr, \"Parameter of type '%s' was not registered.\",\n TypenameAsString());\n const auto result = backend_->set(value);\n if (!result) {\n return result;\n }\n value_ = std::move(value);\n return Success;\n }\n\n // Sets the parameter to the given value, but does not notify the backend about the change.\n // This function shall only be used by the ParameterBackend class.\n void setWithoutPropagate(const T& value) {\n std::unique_lock lock(mutex_);\n value_ = value;\n }\n\n // Connects this parameter frontend to the corresponding backend.\n void connect(ParameterBackend* backend) {\n backend_ = backend;\n }\n\n const char* key() {\n return backend_ == nullptr ? nullptr : backend_->key();\n }\n\n private:\n Expected value_ = Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n ParameterBackend* backend_ = nullptr;\n mutable std::mutex mutex_;\n};\n\n// A specialization of Parameter for handle types.\ntemplate \nclass Parameter> : public ParameterBase {\n public:\n // Gets the current parameter value. Only valid if the parameter is marked as 'mandatory' in the\n // parameter interface. Otherwise an assert will be raised.\n const Handle& get() const {\n GXF_ASSERT(backend_ != nullptr, \"A handle parameter with type '%s' was not registered.\",\n TypenameAsString());\n GXF_ASSERT(backend_->isMandatory(), \"Only mandatory parameters can be accessed with get(). \"\n \"'%s' is not marked as mandatory\", backend_->key());\n GXF_ASSERT(value_, \"Mandatory parameter '%s' was not set.\", backend_->key());\n GXF_ASSERT(value_ != Handle::Unspecified(), \"Handle was created but not assigned.\"\n \"Unspecified handles cannot be accessed.\");\n return value_.value();\n }\n\n // Convenience function for accessing a mandatory parameter.\n operator const Handle&() const {\n return get();\n }\n\n // Tries to get the parameter value. If the parameter is not set or set to\n // Handle::Unspecified() is returned.\n const Expected>& try_get() const {\n if (value_ == Handle::Unspecified()) { return unspecified_handle_; }\n return value_;\n }\n\n // Only if T = Handle\n S* operator->() const {\n return get().get();\n }\n\n // Sets the parameter to the given value.\n Expected set(Handle value) {\n GXF_ASSERT(backend_ != nullptr,\n \"Parameter corresponding to Handle of `%s' was not registered.\",\n TypenameAsString());\n const auto result = backend_->set(value);\n if (!result) {\n return result;\n }\n value_ = std::move(value);\n return Success;\n }\n\n // Sets the parameter to the given value, but does not notify the backend about the change.\n // This function shall only be used by the ParameterBackend class.\n void setWithoutPropagate(const Handle& value) {\n value_ = value;\n }\n\n // Connects this parameter frontend to the corresponding backend.\n void connect(ParameterBackend>* backend) {\n backend_ = backend;\n }\n\n const char* key() {\n return backend_ == nullptr ? nullptr : backend_->key();\n }\n\n private:\n // Used to return an Unexpected when the handle is not specified\n const Expected> unspecified_handle_ = Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n Expected> value_ = Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n ParameterBackend>* backend_ = nullptr;\n};\n\n// -------------------------------------------------------------------------------------------------\n\ntemplate \nvoid ParameterBackend::writeToFrontend() {\n if (frontend_ && value_) {\n frontend_->setWithoutPropagate(*value_);\n }\n}\n\ntemplate \nExpected ParameterBackend::parse(const YAML::Node& node, const std::string& prefix) {\n return ParameterParser::Parse(context(), uid(), key(), node, prefix)\n .map([this] (const T& value) { return set(value); })\n .and_then([this] { writeToFrontend(); });\n}\n\ntemplate \nvoid ParameterBackend>::writeToFrontend() {\n if (frontend_ && value_) {\n frontend_->setWithoutPropagate(*value_);\n }\n}\n\ntemplate \nExpected ParameterBackend>::parse(const YAML::Node& node,\n const std::string& prefix) {\n return ParameterParser>::Parse(context(), uid(), key(), node, prefix)\n .map([this] (const Handle& value) { return set(value); })\n .and_then([this] { writeToFrontend(); });\n}\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CORE_PARAMETER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_parser.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_PARAMETER_PARSER_HPP_\n#define NVIDIA_GXF_STD_PARAMETER_PARSER_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"common/fixed_string.hpp\"\n#include \"common/fixed_vector.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/filepath.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/core/handle.hpp\"\n#include \"yaml-cpp/yaml.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\ntemplate \nstruct ParameterParser;\n\n// Parses a parameter from YAML using the default YAML parser. This class can be specialized to\n// support custom types.\ntemplate \nstruct ParameterParser {\n static Expected Parse(gxf_context_t context, gxf_uid_t component_uid, const char* key,\n const YAML::Node& node, const std::string& prefix) {\n if (!strcmp(key, \"int8\") || !strcmp(key, \"vector_int8\") || !strcmp(key, \"vector_2d_int8\")) {\n GXF_LOG_WARNING(\"type %s is not supported\", key);\n return Unexpected{GXF_PARAMETER_INVALID_TYPE};\n } else {\n try {\n return node.as();\n } catch (...) {\n std::stringstream ss;\n ss << node;\n GXF_LOG_ERROR(\"Could not parse parameter '%s' from '%s'\", key, ss.str().c_str());\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n }\n }\n};\n\n// Specialization of ParameterParser for std::string. The full node is serialized to a string, even\n// though it might contain sub children.\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n try {\n std::stringstream ss;\n ss << node;\n return ss.str();\n } catch (...) {\n std::stringstream ss;\n ss << node;\n GXF_LOG_ERROR(\"Could not parse parameter '%s' from '%s'\", key, ss.str().c_str());\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n }\n};\n\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n try {\n FilePath path;\n std::stringstream ss;\n ss << node;\n path.assign(ss.str());\n return path;\n } catch (...) {\n std::stringstream ss;\n ss << node;\n GXF_LOG_ERROR(\"Could not parse parameter '%s' from '%s'\", key, ss.str().c_str());\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n }\n};\n\n// Specialization of ParameterParser for uint8_t because it is not supported natively by yaml-cpp\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n try {\n return static_cast(node.as());\n } catch (...) {\n std::stringstream ss;\n ss << node;\n GXF_LOG_ERROR(\"Could not parse parameter '%s' from '%s'\", key, ss.str().c_str());\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n }\n};\n\n// Specialization of ParameterParser for FixedString.\n// Substitutes std::string for safety-critical components.\ntemplate \nstruct ParameterParser> {\n static Expected> Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n return ParameterParser::Parse(context, component_uid, key, node, prefix)\n .map([&](std::string str) {\n FixedString string;\n return string.copy(str.data(), str.size())\n .substitute_error(GXF_EXCEEDING_PREALLOCATED_SIZE)\n .substitute(string);\n });\n }\n};\n\n// Specialization of ParameterParser for FixedVector with stack allocation.\n// Substitutes std::array for safety-critical components.\n// TODO(ayusmans): parsing support for FixedVector with heap allocation\ntemplate \nstruct ParameterParser> {\n static Expected> Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n if (!node.IsSequence()) {\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n if (node.size() > N) {\n GXF_LOG_ERROR(\"Parameter size (%zu) exceeds vector capacity (%zu)\", node.size(), N);\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n FixedVector vector;\n for (size_t i = 0; i < node.size(); i++) {\n const auto maybe = ParameterParser::Parse(context, component_uid, key, node[i], prefix);\n if (!maybe) {\n return ForwardError(maybe);\n }\n vector.push_back(std::move(maybe.value()));\n }\n return vector;\n }\n};\n\n// Specialization of ParameterParser for gxf::Handle. It parses the parameter as a string and\n// interprets it as either a component name in the current entity, or as a composed string of the\n// form 'entity_name/component_name'.\ntemplate \nstruct ParameterParser> {\n static Expected> Parse(gxf_context_t context, gxf_uid_t component_uid, const char* key,\n const YAML::Node& node, const std::string& prefix) {\n const char* component_name = \"UNKNOWN\";\n auto code = GxfParameterGetStr(context, component_uid, kInternalNameParameterKey,\n &component_name);\n if (code != GXF_SUCCESS) { return Unexpected{code}; }\n\n gxf_uid_t owner_eid, param_eid;\n const char* owner_entity_name = \"UNKNOWN\";\n std::string param_entity_name;\n // Get the entity of this component\n const gxf_result_t result_1 = GxfComponentEntity(context, component_uid, &owner_eid);\n if (result_1 != GXF_SUCCESS) {\n return Unexpected{result_1};\n }\n\n code = GxfEntityGetName(context, owner_eid, &owner_entity_name);\n if (code != GXF_SUCCESS) { return Unexpected{code}; }\n\n // Parse string from node\n std::string tag;\n try {\n tag = node.as();\n } catch (...) {\n std::stringstream ss;\n ss << node;\n GXF_LOG_ERROR(\"Could not parse parameter '%s' from '%s'\", key, ss.str().c_str());\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n\n std::string handle_component_name;\n const size_t pos = tag.find('/');\n if (pos == std::string::npos) {\n handle_component_name = tag;\n // target param component and owner component reside in the same entity\n param_eid = owner_eid;\n } else {\n handle_component_name = tag.substr(pos + 1);\n\n // Get the entity\n gxf_result_t result_1_with_prefix = GXF_FAILURE;\n // Try using entity name with prefix\n if (!prefix.empty()) {\n param_entity_name = prefix + tag.substr(0, pos);\n // param eid\n result_1_with_prefix = GxfEntityFind(context, param_entity_name.c_str(), ¶m_eid);\n if (result_1_with_prefix != GXF_SUCCESS) {\n GXF_LOG_WARNING(\"Could not find entity (with prefix) '%s' while parsing parameter '%s' \"\n \"of component %s with id %zu\",\n param_entity_name.c_str(), key, component_name, component_uid);\n }\n }\n // Try using entity name without prefix, if lookup with prefix failed\n if (result_1_with_prefix != GXF_SUCCESS) {\n param_entity_name = tag.substr(0, pos);\n // param eid\n const gxf_result_t result_1_no_prefix = GxfEntityFind(context,\n param_entity_name.c_str(), ¶m_eid);\n if (result_1_no_prefix != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Could not find entity '%s' while parsing parameter '%s' of component %s\"\n \" with id %zu\",\n param_entity_name.c_str(), key, component_name, component_uid);\n return Unexpected{result_1_no_prefix};\n } else if (!prefix.empty()) {\n GXF_LOG_WARNING(\"Found entity (without prefix) '%s' while parsing parameter '%s' \"\n \"of component '%s' with id %zu in a subgraph, however the approach is\"\n \" deprecated, please use prerequisites instead\",\n param_entity_name.c_str(), key, component_name, component_uid);\n }\n }\n }\n\n // Get the type id of the component we are are looking for.\n gxf_tid_t tid;\n const gxf_result_t result_2 = GxfComponentTypeId(context, TypenameAsString(), &tid);\n if (result_2 != GXF_SUCCESS) {\n return Unexpected{result_2};\n }\n\n // Find the component in the indicated entity\n // param eid\n gxf_uid_t cid;\n const gxf_result_t result_3 = GxfComponentFind(context, param_eid, tid,\n handle_component_name.c_str(), nullptr, &cid);\n if (result_3 != GXF_SUCCESS) {\n if (handle_component_name == \"\") {\n GXF_LOG_DEBUG(\"Using an handle in entity '%s' with id %zu while parsing \"\n \"parameter '%s' of component '%s' with id %zu. This handle must be set to a valid component\"\n \" before graph activation\",\n owner_entity_name, owner_eid, key, component_name, component_uid);\n return Handle::Unspecified();\n } else {\n GXF_LOG_WARNING(\"Cannot find target paramter component[entity name: %s, component name: %s]\"\n \" in type[%s] \"\n \"for owner component[entity name: %s, component name: %s, cid: %ld], \"\n \"during parsing its parameter[key: %s, value: %s]\",\n param_entity_name.c_str(), handle_component_name.c_str(), // param component info\n TypenameAsString(), // expected param component type\n owner_entity_name, component_name, component_uid, // owner component info\n key, tag.c_str()); // param key:value string presentation\n // print help info\n for (int offset = 0; ; offset++) {\n auto code1 = GxfComponentFind(context, param_eid, GxfTidNull(),\n handle_component_name.c_str(), &offset, &cid);\n if (code1 == GXF_ENTITY_COMPONENT_NOT_FOUND) {\n GXF_LOG_DEBUG(\"No more component instance found as entity/component: %s\",\n tag.c_str());\n break;\n } else if (code1 != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Failed to execute component cid find with eid: %ld, \"\n \"component name: %s, offset: %d\", param_eid, handle_component_name.c_str(), offset);\n return Unexpected{code1};\n }\n const char* component_type_name = nullptr;\n auto code2 = GxfComponentTypeNameFromUID(context, cid, &component_type_name);\n if (code2 != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Failed to find component type name from cid [%ld]\", cid);\n return Unexpected{code2};\n }\n GXF_LOG_WARNING(\"Found component[%s] in type[%s]; \"\n \"however type[%s] is expected for \"\n \"component[entity name: %s, component name: %s, key: %s]\",\n tag.c_str(), component_type_name,\n TypenameAsString(), owner_entity_name, component_name, key);\n }\n // end help info print\n }\n\n return Unexpected{result_3};\n }\n\n return Handle::Create(context, cid);\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_PARAMETER_PARSER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_parser_std.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_PARAMETER_PARSER_STD_HPP_\n#define NVIDIA_GXF_STD_PARAMETER_PARSER_STD_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"yaml-cpp/yaml.h\"\n\n#include \"common/assert.hpp\"\n#include \"common/yaml_parser.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/core/parameter_parser.hpp\"\n#include \"gxf/core/parameter_registrar.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Parses unknown many of known types.\ntemplate \nstruct ParameterParser> {\n static Expected> Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n if (!node.IsSequence()) {\n const char* component_name = \"UNKNOWN\";\n GxfParameterGetStr(context, component_uid, kInternalNameParameterKey, &component_name);\n GXF_LOG_ERROR(\"Parameter '%s' in component '%s' must be a vector\", key, component_name);\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n std::vector result(node.size());\n for (size_t i = 0; i < node.size(); i++) {\n const auto maybe = ParameterParser::Parse(context, component_uid, key, node[i], prefix);\n if (!maybe) {\n return ForwardError(maybe);\n }\n result[i] = std::move(maybe.value());\n }\n return result;\n }\n};\n\n// Parses known many of known types.\ntemplate \nstruct ParameterParser> {\n static Expected> Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n if (!node.IsSequence()) {\n const char* component_name = \"UNKNOWN\";\n GxfParameterGetStr(context, component_uid, kInternalNameParameterKey, &component_name);\n GXF_LOG_ERROR(\"Parameter '%s' in component '%s' must be an array\", key, component_name);\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n if (node.size() != N) {\n GXF_LOG_ERROR(\"Length of parameter array (%zu) does not match required length (%zu)\",\n node.size(), N);\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n std::array result;\n for (size_t i = 0; i < result.size(); i++) {\n const auto maybe = ParameterParser::Parse(context, component_uid, key, node[i], prefix);\n if (!maybe) { return ForwardError(maybe); }\n result[i] = std::move(maybe.value());\n }\n return result;\n }\n};\n\n// Parameter support for std::unordered_map\ntemplate \nstruct ParameterParser> {\n static Expected> Parse(gxf_context_t context,\n gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n if (!node.IsMap()) {\n const char* component_name = \"UNKNOWN\";\n GxfParameterGetStr(context, component_uid, kInternalNameParameterKey, &component_name);\n GXF_LOG_ERROR(\"Parameter '%s' in component '%s' must be a map\", key, component_name);\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n std::unordered_map map;\n for (const auto& iter : node) {\n const std::string& key = iter.first.as();\n const YAML::Node& value = iter.second;\n auto maybe = ParameterParser::Parse(context, component_uid, key.c_str(), value, prefix);\n if (!maybe) {\n return ForwardError(maybe);\n }\n map[key] = std::move(maybe.value());\n }\n return map;\n }\n};\n\n\ntemplate \nstruct ParameterParser> {\n static Expected> Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n try {\n return static_cast>(node.as>());\n } catch (...) {\n std::stringstream ss;\n ss << node;\n GXF_LOG_ERROR(\"Could not parse parameter '%s' from '%s'\", key, ss.str().c_str());\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n }\n};\n\n\n// Template specializations for ParameterInfo to be used during\n// parameter registration in the extension\n\n// Specialized ParameterInfoOverride for parameters of type std::vector\ntemplate \nstruct ParameterInfoOverride> {\n Expected apply(ParameterRegistrar* registrar,\n ParameterRegistrar::ComponentParameterInfo& info) {\n // Get the element info\n ParameterInfoOverride override;\n ParameterRegistrar::ComponentParameterInfo element_info;\n const auto result = override.apply(registrar, element_info);\n if (!result) { return ForwardError(result); }\n info.type = element_info.type;\n info.is_arithmetic = element_info.is_arithmetic;\n info.handle_tid = element_info.handle_tid;\n\n // Fetch the shape of and update it to the current ComponentParameterInfo\n for (int32_t i = 0; i < element_info.rank; ++i) {\n info.shape[i] = element_info.shape[i];\n }\n // A vector increases the rank by 1 and adds shape [-1] to .\n info.shape[element_info.rank] = -1;\n info.rank = element_info.rank + 1;\n\n return Success;\n }\n};\n\n// Specialized ParameterInfoOverride for parameters of type std::array\ntemplate \nstruct ParameterInfoOverride> {\n Expected apply(ParameterRegistrar* registrar,\n ParameterRegistrar::ComponentParameterInfo& info) {\n // Get the element info\n ParameterInfoOverride override;\n ParameterRegistrar::ComponentParameterInfo element_info;\n const auto result = override.apply(registrar, element_info);\n if (!result) { return ForwardError(result); }\n info.type = element_info.type;\n info.is_arithmetic = element_info.is_arithmetic;\n info.handle_tid = element_info.handle_tid;\n\n // Fetch the shape of and update it to the current ComponentParameterInfo\n for (int32_t i = 0; i < element_info.rank; ++i) {\n info.shape[i] = element_info.shape[i];\n }\n // An increases the rank by 1 and adds shape [N] to .\n info.shape[element_info.rank] = N;\n info.rank = element_info.rank + 1;\n\n return Success;\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_PARAMETER_PARSER_STD_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_registrar.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_PARAMETER_REGISTRAR_HPP_\n#define NVIDIA_GXF_STD_PARAMETER_REGISTRAR_HPP_\n\n#include \n#include \n#include \n#include // NOLINT\n#include \n#include \n#include \n#include \n\n#include \"common/memory_utils.hpp\"\n#include \"common/type_utils.hpp\"\n#include \"gxf/core/expected_macro.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/core/parameter.hpp\"\n#include \"gxf/core/type_registry.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// @brief Struct specifying parameters for registering parameter\ntemplate \nstruct ParameterInfo {\n // Key used to access the parameter. Required.\n const char* key = nullptr;\n // Brief description. Optional.\n const char* headline = nullptr;\n // Detailed description. Optional.\n const char* description = nullptr;\n // Applicable platform list separated by comma. Optional.\n const char* platform_information = nullptr;\n\n // Default value if not provided otherwise. Not applicable to Handle parameter. Optional.\n Expected value_default = Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n // Minimal value, Maximum value and Minimal step for arithmetic types. Optional.\n Expected> value_range = Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n\n // Bit flags about properties like if it is required etc.\n gxf_parameter_flags_t flags = GXF_PARAMETER_FLAGS_NONE;\n\n // Max allowed is rank 8\n static constexpr const int32_t kMaxRank = 8;\n // Parameters can be tensors and this value indicates its rank. For a \"scalar\" rank is 0.\n int32_t rank = 0;\n // Parameters can be tensors and this is its shape. Only values up to rank must be set. If rank\n // is 0 no value must be set. -1 can be used to indicate a dynamic size which is not fixed at\n // compile time.\n int32_t shape[kMaxRank] = {1};\n};\n\nclass Component;\n\ntemplate \nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"(custom)\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_CUSTOM;\n static constexpr const bool is_arithmetic = false;\n};\n\ntemplate \nstruct ParameterTypeTrait> {\n static constexpr const char* type_name = \"(handle)\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_HANDLE;\n static constexpr const bool is_arithmetic = false;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"Int8\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_INT8;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"Int16\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_INT16;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"Int32\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_INT32;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"Int64\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_INT64;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"UInt8\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_UINT8;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"UInt16\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_UINT16;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"UInt32\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_UINT32;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"UInt64\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_UINT64;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"Float32\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_FLOAT32;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"Float64\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_FLOAT64;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"String\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_STRING;\n static constexpr const bool is_arithmetic = false;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"String\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_STRING;\n static constexpr const bool is_arithmetic = false;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"Boolean\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_BOOL;\n static constexpr const bool is_arithmetic = false;\n};\n\ntemplate <>\nstruct ParameterTypeTrait {\n static constexpr const char* type_name = \"File\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_FILE;\n static constexpr const bool is_arithmetic = false;\n};\n\ntemplate <>\nstruct ParameterTypeTrait> {\n static constexpr const char* type_name = \"Complex64\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_COMPLEX64;\n static constexpr const bool is_arithmetic = true;\n};\n\ntemplate <>\nstruct ParameterTypeTrait> {\n static constexpr const char* type_name = \"Complex128\";\n static constexpr const gxf_parameter_type_t type = GXF_PARAMETER_TYPE_COMPLEX128;\n static constexpr const bool is_arithmetic = true;\n};\n\n// Stores parameters for an GXF application\nclass ParameterRegistrar {\n public:\n // Container for a single object of any type\n // Contained object is dynamically allocated on the heap and properly destructed when finished\n class TypeEraser {\n public:\n TypeEraser() = default;\n TypeEraser(const TypeEraser& other) { *this = other; }\n TypeEraser(TypeEraser&& other) { *this = std::move(other); }\n template , TypeEraser>, TypeEraser*> = nullptr>\n TypeEraser(T&& value) { *this = std::forward(value); }\n ~TypeEraser() { reset(); }\n\n TypeEraser& operator=(const TypeEraser& other) {\n if (other.instance_) {\n instance_ = other.instance_->clone();\n }\n return *this;\n }\n\n TypeEraser& operator=(TypeEraser&& other) {\n instance_ = std::move(other.instance_);\n return *this;\n }\n\n template \n EnableIf_t, TypeEraser>, TypeEraser&> operator=(T&& value) {\n instance_ = MakeUniqueNoThrow>>(std::forward(value));\n return *this;\n }\n\n bool has_value() const { return static_cast(instance_); }\n const void* get() const { return has_value() ? instance_->get() : nullptr; }\n void reset() { instance_.reset(); }\n\n private:\n struct storage_base {\n virtual ~storage_base() = default;\n virtual const void* get() const = 0;\n virtual std::unique_ptr clone() const = 0;\n };\n\n template \n struct storage_impl final : public storage_base {\n template \n storage_impl(Args&&... args) : value(std::forward(args)...) {}\n\n // FIXME: return c_str() directly for string types to avoid reinterpret_cast\n const void* get() const override { return &value; }\n\n std::unique_ptr clone() const override {\n return MakeUniqueNoThrow>(value);\n }\n\n T value;\n };\n\n std::unique_ptr instance_;\n };\n\n // Struct to hold information about a single parameter\n struct ComponentParameterInfo {\n std::string key;\n std::string headline;\n std::string description;\n\n std::string platform_information;\n\n gxf_parameter_type_t type;\n gxf_tid_t handle_tid = GxfTidNull();\n bool is_arithmetic;\n\n gxf_parameter_flags_t flags;\n\n // params to be accessed only via getDefaultValue(...)\n // and getNumericRange(...) apis\n TypeEraser default_value;\n // Range info as [min, max, step]\n std::array value_range;\n\n int32_t rank = 0;\n int32_t shape[ParameterInfo::kMaxRank] = {0};\n };\n\n // Struct to hold information about all the parameters in a component\n struct ComponentInfo {\n std::string type_name;\n std::vector parameter_keys;\n std::unordered_map parameters;\n };\n\n ParameterRegistrar() = default;\n\n template \n Expected registerComponentParameter(gxf_tid_t tid, const std::string& type_name,\n const ParameterInfo& parameter_info);\n\n template\n Expected>\n getParametersOfType(gxf_tid_t tid);\n\n // Add's a parameterless component to parameter registrar. These are useful to lookup component\n // tid using component type name when parameters of type Handle are being registered\n void addParameterlessType(const gxf_tid_t tid, std::string type_name);\n\n // Check if parameter registrar has a component\n bool hasComponent(const gxf_tid_t tid) const;\n\n // Get the number of parameters in a component\n size_t componentParameterCount(const gxf_tid_t tid) const;\n\n // Get the list of parameter keys in a component\n Expected getParameterKeys(const gxf_tid_t tid, const char** keys, size_t& count) const;\n\n // Check if a component has a parameter\n Expected componentHasParameter(const gxf_tid_t tid, const char* key) const;\n\n // Get the default value of a component\n // Depending on the data type of the parameter, default value has to be\n // casted into the data type specified in gxf_parameter_type_t in gxf.h\n Expected getDefaultValue(const gxf_tid_t tid, const char* key) const;\n\n // Load the numeric range of a parameter into gxf_parameter_info_t\n // Depending on the data type of the parameter, numeric ranges value have to be\n // casted into the data type specified in gxf_parameter_type_t in gxf.h\n Expected getNumericRange(const gxf_tid_t tid, const char* key,\n gxf_parameter_info_t* info) const;\n\n // fills the gxf_parameter_info_t struct with the info stored in the parameter registrar\n // for that specific component and parameter key\n Expected getParameterInfo(const gxf_tid_t tid, const char* key,\n gxf_parameter_info_t* info) const;\n\n // Returns the pointer to ComponentParameterInfo object in ComponentInfo\n Expected getComponentParameterInfoPtr(const gxf_tid_t tid,\n const char* key) const;\n\n // Get the tid of a component which has already been registered with the type registry,\n // returns Unexpected if component not found\n Expected tidFromTypename(std::string type_name) {\n for (const auto& cparam : component_parameters) {\n if (cparam.second->type_name == type_name) {\n return cparam.first;\n }\n }\n GXF_LOG_ERROR(\"Component type not found %s\", type_name.c_str());\n return Unexpected{GXF_ENTITY_COMPONENT_NOT_FOUND};\n }\n\n private:\n // Verifies the info of a new parameter being registered and fills the info\n // in the ComponentParameterInfo struct which is returned\n Expected registerComponentParameterImpl(gxf_tid_t tid, const std::string& type_name,\n ComponentParameterInfo& info);\n\n // Maintains a map of {tid : ComponentInfo}\n // component type name in ComponentInfo is used to look up the corresponding tid when a parameter\n // of handle is used for that component\n std::map> component_parameters;\n};\n\n// loads numeric range info from ComponentParameterInfo to gxf_parameter_info_t\ntemplate \nstatic bool getNumericRangeImpl(ParameterRegistrar::ComponentParameterInfo* ptr,\n gxf_parameter_info_t* info) {\n static_assert(ParameterTypeTrait::is_arithmetic);\n\n if (!ptr || !info) {\n return false;\n }\n\n info->numeric_min = nullptr;\n info->numeric_max = nullptr;\n info->numeric_step = nullptr;\n\n if (std::get<0>(ptr->value_range).has_value()) {\n info->numeric_min = std::get<0>(ptr->value_range).get();\n }\n if (std::get<1>(ptr->value_range).has_value()) {\n info->numeric_max = std::get<1>(ptr->value_range).get();\n }\n if (std::get<2>(ptr->value_range).has_value()) {\n info->numeric_step = std::get<2>(ptr->value_range).get();\n }\n\n return true;\n}\n\n// Provides a customizable step which can be used during parameter registration to modify\n// parameter info given to registry before it is written to the parameter info storage.\ntemplate \nstruct ParameterInfoOverride {\n Expected apply(ParameterRegistrar* /*registrar*/,\n ParameterRegistrar::ComponentParameterInfo& info) {\n info.type = ParameterTypeTrait::type;\n info.is_arithmetic = ParameterTypeTrait::is_arithmetic;\n info.handle_tid = GxfTidNull();\n return Success;\n }\n};\n\n// Specialized ParameterInfoOverride for parameters of type handle\ntemplate \nstruct ParameterInfoOverride> {\n Expected apply(ParameterRegistrar* registrar,\n ParameterRegistrar::ComponentParameterInfo& info) {\n info.type = GXF_PARAMETER_TYPE_HANDLE;\n info.is_arithmetic = false;\n auto handle = registrar->tidFromTypename(TypenameAsString());\n if (!handle) { return ForwardError(handle); }\n info.handle_tid = handle.value();\n return Success;\n }\n};\n\ntemplate \nExpected ParameterRegistrar::registerComponentParameter(\n gxf_tid_t tid, const std::string& type_name, const ParameterInfo& registrar_info) {\n\n ComponentParameterInfo info;\n\n if (registrar_info.key == nullptr) {\n return Unexpected{GXF_ARGUMENT_NULL};\n }\n info.key = std::string{registrar_info.key};\n\n if (registrar_info.headline == nullptr) {\n return Unexpected{GXF_ARGUMENT_NULL};\n }\n info.headline = std::string{registrar_info.headline};\n\n if (registrar_info.description == nullptr) {\n return Unexpected{GXF_ARGUMENT_NULL};\n }\n info.description = std::string{registrar_info.description};\n\n // Handles platform information if present\n if (registrar_info.platform_information != nullptr) {\n info.platform_information = std::string{registrar_info.platform_information};\n }\n\n if (registrar_info.value_default) {\n info.default_value = *registrar_info.value_default;\n } else {\n info.default_value.reset();\n }\n\n if (registrar_info.value_range) {\n std::get<0>(info.value_range) = std::get<0>(*registrar_info.value_range);\n std::get<1>(info.value_range) = std::get<1>(*registrar_info.value_range);\n std::get<2>(info.value_range) = std::get<2>(*registrar_info.value_range);\n } else {\n std::get<0>(info.value_range).reset();\n std::get<1>(info.value_range).reset();\n std::get<2>(info.value_range).reset();\n }\n\n info.flags = registrar_info.flags;\n\n // Set the rank and make sure the shape is correct.\n info.rank = registrar_info.rank;\n if (info.rank > ParameterInfo::kMaxRank) {\n return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};\n }\n\n for (int32_t i = 0; i < info.rank; i++) {\n info.shape[i] = registrar_info.shape[i];\n }\n for (int32_t i = info.rank; i < ParameterInfo::kMaxRank; i++) {\n info.shape[i] = 1;\n }\n\n // Apply custom overrides\n ParameterInfoOverride custom_override;\n const auto result = custom_override.apply(this, info);\n if (!result) {\n GXF_LOG_ERROR(\"Parameter Override failed for Component \\\"%s\\\" and Parameter \\\"%s\\\"\",\n type_name.c_str(), registrar_info.key);\n return result;\n }\n\n // register the parameter\n return registerComponentParameterImpl(tid, type_name, info);\n}\n\n// Provides a customizable step which can be used to query parameter info\ntemplate \nstruct ParameterQueryOverride {\n Expected> query(\n ParameterRegistrar* registrar, gxf_tid_t tid) {\n std::string type_name{TypenameAsString()};\n size_t count = registrar->componentParameterCount(tid);\n const char* keys[count];\n GXF_RETURN_IF_ERROR(registrar->getParameterKeys(tid, keys, count));\n std::vector result;\n for (size_t i = 0; i < count; ++i) {\n auto info = GXF_UNWRAP_OR_RETURN(registrar->getComponentParameterInfoPtr(tid, keys[i]));\n if (info->type == ParameterTypeTrait::type) {\n result.push_back(*info);\n }\n }\n return result;\n }\n};\n\n// Specialized ParameterInfoOverride for parameters of type handle\ntemplate \nstruct ParameterQueryOverride> {\n Expected> query(\n ParameterRegistrar* registrar, gxf_tid_t tid) {\n std::string type_name{TypenameAsString()};\n auto query_tid = GXF_UNWRAP_OR_RETURN(registrar->tidFromTypename(type_name));\n size_t count = registrar->componentParameterCount(tid);\n const char* keys[count];\n GXF_RETURN_IF_ERROR(registrar->getParameterKeys(tid, keys, count));\n std::vector result;\n for (size_t i = 0; i < count; ++i) {\n auto info = GXF_UNWRAP_OR_RETURN(registrar->getComponentParameterInfoPtr(tid, keys[i]));\n if (info->type != GXF_PARAMETER_TYPE_HANDLE ) {continue;}\n if (info->handle_tid == query_tid) {\n result.push_back(*info);\n }\n }\n return result;\n }\n};\n\ntemplate\nExpected>\n ParameterRegistrar::getParametersOfType(gxf_tid_t tid) {\n ParameterQueryOverride override;\n return override.query(this, tid);\n }\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_PARAMETER_REGISTRAR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_storage.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_PARAMETER_STORAGE_HPP_\n#define NVIDIA_GXF_STD_PARAMETER_STORAGE_HPP_\n\n#include \n#include \n#include \n#include \n#include // NOLINT\n#include \n#include \n\n#include \"gxf/core/parameter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Stores all parameters for an GXF application\n//\n// Parameters are stored in a dictionary style class. For each parameter the actual parameter value\n// and various helper classes to query and set parameters are provided.\nclass ParameterStorage {\n public:\n ParameterStorage(gxf_context_t context);\n\n // Registers a parameter with the backend. This is used by components when they register their\n // parameter interface to connect parameters in components to the backend.\n template \n Expected registerParameter(nvidia::gxf::Parameter* frontend, gxf_uid_t uid,\n const char* key, const char* headline, const char* description,\n Expected default_value, gxf_parameter_flags_t flags) {\n if (frontend == nullptr) { return Unexpected{GXF_ARGUMENT_NULL}; }\n if (key == nullptr) { return Unexpected{GXF_ARGUMENT_NULL}; }\n if (headline == nullptr) { return Unexpected{GXF_ARGUMENT_NULL}; }\n if (description == nullptr) { return Unexpected{GXF_ARGUMENT_NULL}; }\n\n std::unique_lock lock(mutex_);\n\n auto it = parameters_.find(uid);\n if (it == parameters_.end()) {\n std::map> tmp;\n it = parameters_.insert({uid, std::move(tmp)}).first;\n }\n\n const auto jt = it->second.find(key);\n if (jt != it->second.end()) { return Unexpected{GXF_PARAMETER_ALREADY_REGISTERED}; }\n\n auto backend = std::make_unique>();\n backend->context_ = context_;\n backend->uid_ = uid;\n backend->flags_ = flags;\n backend->is_dynamic_ = false;\n backend->key_ = key;\n backend->headline_ = headline;\n backend->description_ = description;\n backend->frontend_ = frontend;\n // FIXME(v1) validator\n\n frontend->connect(backend.get());\n\n if (default_value) {\n const auto code = backend->set(std::move(*default_value));\n if (!code) { return ForwardError(code); }\n backend->writeToFrontend();\n }\n\n it->second.insert({key, std::move(backend)}).first;\n\n return Success;\n }\n\n Expected parse(gxf_uid_t uid, const char* key, const YAML::Node& node,\n const std::string& prefix);\n\n Expected wrap(gxf_uid_t uid, const char* key);\n\n // Sets a parameter. If the parameter is not yet present a new dynamic parameter will be created.\n // This function fails if a parameter already exists, but with the wrong type.\n template \n Expected set(gxf_uid_t uid, const char* key, T value) {\n std::unique_lock lock(mutex_);\n\n GXF_LOG_VERBOSE(\"Setting parameter [%s] of type [%s] on uid [%\" PRId64 \"]\", key,\n TypenameAsString(), uid);\n auto it = parameters_.find(uid);\n if (it == parameters_.end()) {\n std::map> tmp;\n it = parameters_.insert({uid, std::move(tmp)}).first;\n }\n\n auto jt = it->second.find(key);\n if (jt == it->second.end()) {\n auto ptr = std::make_unique>();\n ptr->context_ = context_;\n ptr->uid_ = uid;\n ptr->flags_ = GXF_PARAMETER_FLAGS_OPTIONAL | GXF_PARAMETER_FLAGS_DYNAMIC;\n ptr->is_dynamic_ = true;\n ptr->key_ = key;\n ptr->headline_ = key;\n ptr->description_ = \"N/A\";\n jt = it->second.insert({key, std::move(ptr)}).first;\n }\n\n auto* ptr = dynamic_cast*>(jt->second.get());\n if (ptr == nullptr) {\n GXF_LOG_ERROR(\"Attempting to set invalid parameter type for [%s] with type [%s]\",\n key, TypenameAsString());\n return Unexpected{GXF_PARAMETER_INVALID_TYPE};\n }\n\n const auto code = ptr->set(std::move(value));\n if (!code) { return ForwardError(code); }\n\n ptr->writeToFrontend(); // FIXME(v1) Special treatment for codelet parameters\n return Success;\n }\n\n // Gets a parameter\n template \n Expected get(gxf_uid_t uid, const char* key) const {\n std::shared_lock lock(mutex_);\n return getValuePointer(uid, key).map([](const T* pointer) { return *pointer; });\n }\n\n // Sets a string parameter. The storage creates it's own internal copy and does not take ownership\n // of the given pointer.\n Expected setStr(gxf_uid_t uid, const char* key, const char* value);\n\n // Gets a string parameter. A pointer to the internal storage is returned whose contents may\n // change if a call to setStr happens in the meantime.\n Expected getStr(gxf_uid_t uid, const char* key) const;\n\n // Sets a file path parameter.\n Expected setPath(gxf_uid_t, const char* key, const char* value);\n\n // Gets a file path parameter. A pointer to the internal storage is returned whose contents may\n // change if a call to setPath happens in the meantime.\n Expected getPath(gxf_uid_t uid, const char* key) const;\n\n // Sets a handle parameter.\n Expected setHandle(gxf_uid_t, const char* key, gxf_uid_t value);\n\n // Gets a handle parameter.\n Expected getHandle(gxf_uid_t uid, const char* key) const;\n\n // Sets a vector of string parameter. The storage creates it's own internal copy and does not take\n // ownership of the given pointer.\n Expected setStrVector(gxf_uid_t uid, const char* key, const char** value, uint64_t length);\n\n // Adds the given value to a parameter and returns the result. The parameter is initialized to\n // 0 in case it does not exist.\n Expected addGetInt64(gxf_uid_t uid, const char* key, int64_t delta);\n\n // Returns true if all mandatory parameters are available\n Expected isAvailable() const;\n\n // Returns true if all mandatory parameters of a component are available\n Expected isAvailable(gxf_uid_t uid) const;\n\n // Clean up data for specific Entity upon Entity destruction\n Expected clearEntityParameters(gxf_uid_t eid);\n\n private:\n friend class Runtime;\n\n // Finds a parameter and returns a pointer to its value.\n template \n Expected getValuePointer(gxf_uid_t uid, const char* key) const {\n std::shared_lock lock(mutex_);\n auto backend = getBackendPointerImpl>(uid, key);\n if (!backend) { return ForwardError(backend); }\n const auto& maybe = backend.value()->try_get();\n if (!maybe) { return Unexpected{GXF_PARAMETER_NOT_INITIALIZED}; }\n return &(*maybe);\n }\n\n // Finds a parameter backend and returns a pointer to it.\n template \n Expected getBackendPointerImpl(gxf_uid_t uid, const char* key) const {\n const auto it = parameters_.find(uid);\n if (it == parameters_.end()) { return Unexpected{GXF_PARAMETER_NOT_FOUND}; }\n const auto jt = it->second.find(key);\n if (jt == it->second.end()) { return Unexpected{GXF_PARAMETER_NOT_FOUND}; }\n\n const T* ptr = dynamic_cast(jt->second.get());\n if (ptr == nullptr) { return Unexpected{GXF_PARAMETER_INVALID_TYPE}; }\n return ptr;\n }\n\n // Finds a parameter backend and returns a pointer to it.\n template \n Expected getBackendPointerImpl(gxf_uid_t uid, const char* key) {\n const auto it = parameters_.find(uid);\n if (it == parameters_.end()) { return Unexpected{GXF_PARAMETER_NOT_FOUND}; }\n const auto jt = it->second.find(key);\n if (jt == it->second.end()) { return Unexpected{GXF_PARAMETER_NOT_FOUND}; }\n\n T* ptr = dynamic_cast(jt->second.get());\n if (ptr == nullptr) { return Unexpected{GXF_PARAMETER_INVALID_TYPE}; }\n return ptr;\n }\n\n mutable std::shared_timed_mutex mutex_;\n gxf_context_t context_;\n std::map>> parameters_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_PARAMETER_STORAGE_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_wrapper.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_PARAMETER_WRAPPER_HPP_\n#define NVIDIA_GXF_STD_PARAMETER_WRAPPER_HPP_\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"common/yaml_parser.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/core/handle.hpp\"\n#include \"yaml-cpp/yaml.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\ntemplate \nstruct ParameterWrapper;\n\ntemplate \nstruct ParameterWrapper {\n // Wrap the value to a YAML::Node instance\n static Expected Wrap(gxf_context_t context, const T& value) {\n return YAML::Node(value);\n }\n};\n\ntemplate \nstruct ParameterWrapper> {\n static Expected Wrap(gxf_context_t context, const Handle& value) {\n std::string c_name = value.name();\n const char *entity_name;\n gxf_uid_t eid = kNullUid;\n auto result = GxfComponentEntity(context, value.cid(), &eid);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Unable to find the entity for %s\", c_name.c_str());\n return Unexpected{result};\n }\n result = GxfEntityGetName(context, eid, &entity_name);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"Unable to get the entity name\");\n return Unexpected{result};\n }\n\n std::string full_name = std::string(entity_name) + \"/\" + c_name;\n return YAML::Node(full_name);\n }\n};\n\ntemplate\nstruct ParameterWrapper>> {\n static Expected Wrap(\n gxf_context_t context,\n const std::vector>& value) {\n YAML::Node node(YAML::NodeType::Sequence);\n for (auto &h : value) {\n auto maybe = ParameterWrapper>::Wrap(context, h);\n if (!maybe) {\n return Unexpected{maybe.error()};\n }\n node.push_back(maybe.value());\n }\n return node;\n }\n};\n\ntemplate\nstruct ParameterWrapper, N>> {\n static Expected Wrap(\n gxf_context_t context,\n const std::array, N>& value) {\n YAML::Node node(YAML::NodeType::Sequence);\n for (auto &h : value) {\n auto maybe = ParameterWrapper>::Wrap(context, h);\n if (!maybe) {\n return Unexpected{maybe.error()};\n }\n node.push_back(maybe.value());\n }\n return node;\n }\n};\n\ntemplate\nstruct ParameterWrapper> {\n static Expected Wrap(\n gxf_context_t context,\n const std::unordered_map& map) {\n YAML::Node node(YAML::NodeType::Map);\n for (const auto& iter : map) {\n const std::string& key = iter.first;\n const T& value = iter.second;\n auto maybe = ParameterWrapper::Wrap(context, value);\n if (!maybe) {\n return ForwardError(maybe);\n }\n node[key] = std::move(maybe.value());\n }\n return node;\n }\n};\n\ntemplate\nstruct ParameterWrapper> {\n static Expected Wrap(\n gxf_context_t context,\n const nvidia::FixedVector& value) {\n YAML::Node node(YAML::NodeType::Sequence);\n for (size_t i = 0; i < value.size(); i++) {\n auto v = value.at(i).value();\n auto maybe = ParameterWrapper::Wrap(context, v);\n if (!maybe) {\n return Unexpected{maybe.error()};\n }\n node.push_back(maybe.value());\n }\n return node;\n }\n};\n\ntemplate\nstruct ParameterWrapper> {\n static Expected Wrap(\n gxf_context_t context,\n const nvidia::FixedString& value) {\n return ParameterWrapper::Wrap(context, std::string(value.c_str()));\n }\n};\n\ntemplate\nstruct ParameterWrapper, N>> {\n static Expected Wrap(\n gxf_context_t context,\n const nvidia::FixedVector, N>& value) {\n YAML::Node node(YAML::NodeType::Sequence);\n for (size_t i = 0; i < value.size(); i++) {\n auto h = value.at(i).value();\n auto maybe = ParameterWrapper>::Wrap(context, h);\n if (!maybe) {\n return Unexpected{maybe.error()};\n }\n node.push_back(maybe.value());\n }\n return node;\n }\n};\n\ntemplate<>\nstruct ParameterWrapper {\n static Expected Wrap(\n gxf_context_t context,\n const nvidia::gxf::FilePath& value) {\n return ParameterWrapper::Wrap(context, value);\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/registrar.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_REGISTRAR_HPP_\n#define NVIDIA_GXF_CORE_REGISTRAR_HPP_\n\n#include \n#include \n#include // NOLINT\n#include \n#include \n#include \n\n#include \"gxf/core/parameter.hpp\"\n#include \"gxf/core/parameter_registrar.hpp\"\n#include \"gxf/core/parameter_storage.hpp\"\n#include \"gxf/core/resource.hpp\"\n#include \"gxf/core/resource_manager.hpp\"\n#include \"gxf/core/resource_registrar.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Registers parameters and other information of components\nclass Registrar {\n public:\n // Constant for registering an optional parameter with no default value\n static constexpr Unexpected NoDefaultParameter() {\n return Unexpected{GXF_PARAMETER_NOT_INITIALIZED};\n }\n\n Registrar() = default;\n\n // Simplified version of 'parameter'.\n template \n Expected parameter(Parameter& parameter, const char* key) {\n return parameterImpl(parameter, {key, key, \"N/A\"});\n }\n\n // Simplified version of 'parameter'.\n template \n Expected parameter(Parameter& parameter, const char* key, const char* headline) {\n return parameterImpl(parameter, {key, headline, \"N/A\"});\n }\n\n // Simplified version of 'parameter'.\n template \n Expected parameter(Parameter& parameter, const char* key, const char* headline,\n const char* description) {\n return parameterImpl(parameter, {key, headline, description});\n }\n\n // Simplified version of 'parameter'.\n template \n Expected parameter(Parameter& parameter, const char* key, const char* headline,\n const char* description, const T& default_value) {\n ParameterInfo info;\n info.key = key;\n info.headline = headline;\n info.description = description;\n info.value_default = default_value;\n return parameterImpl(parameter, info);\n }\n\n // Register a component parameter. Every parameter must be registered in the function\n // 'registerInterface'.\n template \n Expected parameter(Parameter& parameter, const char* key, const char* headline,\n const char* description, const T& default_value,\n gxf_parameter_flags_t flags) {\n ParameterInfo info;\n info.key = key;\n info.headline = headline;\n info.description = description;\n info.value_default = default_value;\n info.flags = flags;\n return parameterImpl(parameter, info);\n }\n\n // Register a component parameter. Every parameter must be registered in the function\n // 'registerInterface'.\n template \n Expected parameter(Parameter& parameter, const char* key, const char* headline,\n const char* description, Unexpected, gxf_parameter_flags_t flags) {\n ParameterInfo info;\n info.key = key;\n info.headline = headline;\n info.description = description;\n info.flags = flags;\n return parameterImpl(parameter, info);\n }\n\n // Registers with a struct of all info.\n template \n Expected parameter(nvidia::gxf::Parameter& parameter,\n const ParameterInfo& parameter_info) {\n return parameterImpl(parameter, parameter_info);\n }\n\n // Implementation for parameter() above that registers parameter in ParameterRegistrar and\n // ParameterStorage.\n // register component's Parameter class members. Two usages:\n // 1. Register, maintain a map { comp_tid : parameter_info{tid} }\n // when Runtime call Component::registerInterface() in GxfRegisterComponent()\n // set parameter_registrar != nullptr && a mock parameter_storage\n // 2. Populate ParameterStorage, maintain a map { comp_cid : backend_parameters }\n // create each backend_parameter, connect corresponding frontend_parameter\n // when Runtime call Component::registerInterface() in GxfComponentAdd()\n // set parameter_registrar == nullptr && parameter_storage != nullptr\n template \n Expected parameterImpl(nvidia::gxf::Parameter& parameter,\n const ParameterInfo& parameter_info) {\n if (parameter_registrar != nullptr) {\n Expected result =\n parameter_registrar->registerComponentParameter(tid, type_name, parameter_info);\n if (!result) { return ForwardError(result); }\n }\n\n if (parameter_storage == nullptr) { return Unexpected{GXF_CONTEXT_INVALID}; }\n return parameter_storage->registerParameter(\n ¶meter, cid, parameter_info.key, parameter_info.headline, parameter_info.description,\n parameter_info.value_default, parameter_info.flags);\n }\n\n // Registers a component with no parameters\n Expected registerParameterlessComponent() {\n if (parameter_registrar != nullptr) parameter_registrar->addParameterlessType(tid, type_name);\n return Success;\n }\n\n // register component's Resource class members. Two usages:\n // 1. Register, maintain a map { comp_tid : resources_info{tid} }\n // when Runtime call Component::registerInterface() in GxfRegisterComponent()\n // set resource_registrar != nullptr && resource_manager = nullptr\n // 2. Connect, assign ResourceManager ptr to each resource class member\n // when Runtime call Component::registerInterface() in GxfComponentAdd()\n // set resource_registrar == nullptr && resource_manager != nullptr\n template \n Expected resource(Resource>& resource, const char* description) {\n // only for first time Runtime call Component::registerInterface(),\n // i.e. register by GxfRegisterComponent()\n if (resource_registrar != nullptr) {\n Expected result =\n resource_registrar->registerComponentResource(tid, type_name.c_str(), description);\n if (!result) { return ForwardError(result); }\n }\n // only for second time Runtime call Component::registerInterface(),\n // i.e. allocate by GxfComponentAdd()\n if (resource_manager != nullptr) {\n // resource_manager is empty at this stage,\n // but should be populated before resource value query\n Expected result1 = resource.connect(resource_manager, cid);\n if (!result1) { return ForwardError(result1); }\n }\n return Success;\n }\n\n // Sets the mandatory parameter storage where parameters loaded from YAML are stored.\n void setParameterStorage(std::shared_ptr param_storage) {\n parameter_storage = param_storage;\n }\n\n // Gets the mandatory parameter storage where parameters loaded from YAML are stored.\n ParameterStorage* getParameterStorage() { return parameter_storage.get(); }\n\n // Sets parameter registrar\n void setParameterRegistrar(ParameterRegistrar* param_registrar) {\n parameter_registrar = param_registrar;\n }\n\n // Gets the parameter registrar used to register the component interface\n ParameterRegistrar* getParameterRegistrar() { return parameter_registrar; }\n\n // Sets resource registrar\n void setResourceRegistrar(std::shared_ptr resource_registrar) {\n this->resource_registrar = resource_registrar;\n }\n\n // Sets resource manager\n void setResourceManager(std::shared_ptr resource_manager) {\n this->resource_manager = resource_manager;\n }\n\n std::shared_ptr parameter_storage = nullptr;\n\n // Stores information about parameter for query\n ParameterRegistrar* parameter_registrar = nullptr;\n\n std::shared_ptr resource_registrar = nullptr;\n\n // have to stick to shared_ptr to avoid nullptr dereferencing risk,\n // as Codelet's Resource try_get() are lazy call\n std::shared_ptr resource_manager;\n\n // The type id of registering component\n gxf_tid_t tid;\n // The instance uid of registering component\n gxf_uid_t cid = 0;\n // The typename of the registering component\n std::string type_name;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CORE_REGISTRAR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/resource.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_CORE_RESOURCE_HPP_\n#define NVIDIA_GXF_CORE_RESOURCE_HPP_\n\n#include \n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/core/resource_manager.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\ntemplate \nclass Resource;\n\ntemplate \nclass Resource> {\n public:\n // Tries to get the Resource value. If first time call, query ResourceManager and save\n // the value for subsequent calls.\n // If invalid ResourceManager ptr, Handle::Unspecified() keeps returning every time\n // If ResourceManager cannot find the target, GXF_ENTITY_COMPONENT_NOT_FOUND\n // will be saved into value_. No repeat query.\n const Expected>& try_get(const char* name = nullptr) const {\n if (value_ == Handle::Unspecified()) {\n if (resource_manager_ == nullptr) {\n GXF_LOG_WARNING(\"Resource [type: %s] from component [cid: %ld] cannot get \"\n \"its value because of nullptr ResourceManager\",\n TypenameAsString(), owner_cid_);\n return unspecified_handle_;\n } else {\n Expected> maybe_value =\n resource_manager_->findComponentResource(owner_cid_, name);\n if (!maybe_value) {\n GXF_LOG_DEBUG(\"Resource [type: %s] from component [cid: %ld] \"\n \"cannot find its value from ResourceManager\",\n TypenameAsString(), owner_cid_);\n value_ = ForwardError(maybe_value);\n return value_;\n }\n value_ = maybe_value.value();\n }\n }\n return value_;\n }\n\n Expected connect(std::shared_ptr resource_manager, gxf_uid_t owner_cid) {\n if (resource_manager == nullptr) {\n GXF_LOG_WARNING(\"nullptr ResourceManager ptr passed to connect Resource: %s from cid: %ld\",\n TypenameAsString(), owner_cid);\n }\n resource_manager_ = resource_manager;\n owner_cid_ = owner_cid;\n return Success;\n }\n\n private:\n gxf_uid_t owner_cid_ = 0;\n std::shared_ptr resource_manager_;\n mutable Expected> value_ = Handle::Unspecified();\n // Used to return an Unexpected when the handle is not specified\n const Expected> unspecified_handle_ = Unexpected{GXF_RESOURCE_NOT_INITIALIZED};\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CORE_RESOURCE_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/resource_manager.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_GXF_STD_RESOURCE_MANAGER_HPP_\n#define NVIDIA_GXF_GXF_STD_RESOURCE_MANAGER_HPP_\n\n#include \n#include \n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/core/handle.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/// @brief Provide lookup from eid & resource type to resource_cids\nclass ResourceManager {\n public:\n ResourceManager(gxf_context_t context);\n virtual ~ResourceManager() = default;\n\n // Static public interface\n static Expected findEntityResourceByTypeName(gxf_context_t context,\n gxf_uid_t eid, const char* type_name,\n const char* target_resource_name = nullptr);\n\n // Static public interface\n static Expected findComponentResourceByTypeName(gxf_context_t context,\n gxf_uid_t cid, const char* type_name,\n const char* target_resource_name = nullptr);\n\n\n // Static public interface\n // Find Resource of type Handle belong to entity eid\n template \n static Expected> findEntityResource(gxf_context_t context, gxf_uid_t eid,\n const char* target_resource_name = nullptr) {\n const char* type_name = TypenameAsString();\n Expected maybe_cid = ResourceManager::findEntityResourceByTypeName(context,\n eid, type_name, target_resource_name);\n if (!maybe_cid) { return ForwardError(maybe_cid); }\n return Handle::Create(context, maybe_cid.value());\n }\n\n\n // Find Resource of type Handle belong to entity eid\n template \n Expected> findEntityResource(gxf_uid_t eid,\n const char* target_resource_name = nullptr) {\n // object member function calls class static function\n return ResourceManager::findEntityResource(context_, eid, target_resource_name);\n }\n\n\n // Find Resource of type Handle belong to component cid\n template \n Expected> findComponentResource(gxf_uid_t cid,\n const char* target_resource_name = nullptr) {\n const char* type_name = TypenameAsString();\n Expected maybe_cid = ResourceManager::findComponentResourceByTypeName(context_,\n cid, type_name, target_resource_name);\n if (!maybe_cid) { return ForwardError(maybe_cid); }\n return Handle::Create(context_, maybe_cid.value());\n }\n\n private:\n gxf_context_t context_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GXF_STD_RESOURCE_MANAGER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/resource_registrar.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_GXF_STD_RESOURCE_REGISTRAR_HPP_\n#define NVIDIA_GXF_GXF_STD_RESOURCE_REGISTRAR_HPP_\n\n#include \n#include \n#include \n\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/// @brief Maintains a map of {component_tid : ComponentInfo(Resources)}\nclass ResourceRegistrar {\n public:\n ResourceRegistrar(gxf_context_t context) : context_(context) {}\n // Struct to hold information about a single Resource\n struct ComponentResourceInfo {\n gxf_tid_t handle_tid = GxfTidNull();\n std::string description;\n };\n\n // Struct to hold information about all the Resources in a component\n struct ComponentInfo {\n std::string type_name;\n std::map resources;\n };\n\n template \n Expected registerComponentResource(gxf_tid_t comp_tid,\n const char* comp_type_name,\n const char* resource_description) {\n auto it = component_resources_.find(comp_tid);\n if (it == component_resources_.end()) {\n component_resources_[comp_tid] = std::make_unique();\n it = component_resources_.find(comp_tid);\n }\n gxf_tid_t resource_tid;\n gxf_result_t result = GxfComponentTypeId(context_, TypenameAsString(), &resource_tid);\n if (result != GXF_SUCCESS) {\n GXF_LOG_ERROR(\"ResourceRegistrar: Runtime cannot \"\n \"find tid of resource [type name: %s]\", TypenameAsString());\n return Unexpected { result };\n }\n const auto jt = it->second->resources.find(resource_tid);\n if (jt != it->second->resources.end()) {\n return Unexpected{GXF_PARAMETER_ALREADY_REGISTERED};\n }\n ComponentResourceInfo info;\n info.handle_tid = resource_tid;\n info.description = std::string(resource_description);\n it->second->type_name = comp_type_name;\n it->second->resources[info.handle_tid] = info;\n\n return Success;\n }\n\n private:\n gxf_context_t context_;\n std::map> component_resources_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GXF_STD_RESOURCE_REGISTRAR_HPP_\n\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/core/type_registry.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_TYPE_REGISTRY_HPP\n#define NVIDIA_GXF_STD_TYPE_REGISTRY_HPP\n\n#include \n#include \n#include // NOLINT\n#include \n\n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A type registry which maps a C++ type to it's name and which can be used to\n// track base classes.\nclass TypeRegistry {\n public:\n Expected add(gxf_tid_t tid, const char* component_type_name);\n\n Expected add_base(const char* component_type_name, const char* base_type_name);\n\n Expected id_from_name(const char* component_type_name) const;\n\n Expected is_base(gxf_tid_t derived, gxf_tid_t base) const;\n\n Expected name(gxf_tid_t tid) const;\n\n private:\n std::map names_;\n std::map tids_;\n std::map> bases_;\n mutable std::shared_timed_mutex mutex_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_ALLOCATOR_HPP\n#define NVIDIA_GXF_CUDA_ALLOCATOR_HPP\n\n#include \n#include \n\n#include \"gxf/std/allocator.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief Provides both synchronous and asynchronous allocation and deallocation of memory.\n */\nclass CudaAllocator : public Allocator {\n public:\n virtual Expected allocate_async(uint64_t size, cudaStream_t stream);\n virtual Expected free_async(byte* pointer, cudaStream_t stream);\n virtual gxf_result_t allocate_async_abi(uint64_t, void**, cudaStream_t) = 0;\n virtual gxf_result_t free_async_abi(void*, cudaStream_t) = 0;\n virtual Expected get_pool_size(MemoryStorageType type) const = 0;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_ALLOCATOR_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_buffer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_CUDA_BUFFER_HPP_\n#define NVIDIA_GXF_CUDA_CUDA_BUFFER_HPP_\n\n#include \n#include \n\n#include \"common/byte.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/cuda/cuda_allocator.hpp\"\n#include \"gxf/cuda/cuda_common.hpp\"\n#include \"gxf/cuda/cuda_stream.hpp\"\n#include \"gxf/cuda/cuda_stream_pool.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/memory_buffer.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nconstexpr const char* kDefaultCudaBufferName = \"gxf_cuda_buffer\";\n\n/**\n * @brief A container for a single block of cuda memory with support for async memory allocations.\n *\n * Each CudaBuffer is type of MemoryBuffer associated with a CudaAllocator, CudaStreamPool &\n * CudaStream. Memory is allocated by resizing the buffer. Both cuda memory and the cuda stream is\n * released back into the pool when a cuda buffer object is destroyed.\n */\nclass CudaBuffer : public MemoryBuffer {\n public:\n // state of the buffer\n enum class State : int8_t {\n UNSET = 0, // Initial state not waiting for any cuda event callback\n CALLBACK_REGISTERED, // Indicates a call back function is registered\n DATA_AVAILABLE, // Indicates data is ready to be consumed\n };\n\n CudaBuffer() = default;\n CudaBuffer(const CudaBuffer&) = delete;\n CudaBuffer& operator=(const CudaBuffer&) = delete;\n\n CudaBuffer(CudaBuffer&& other) noexcept { *this = std::move(other); }\n\n CudaBuffer& operator=(CudaBuffer&& other) noexcept {\n if (this == &other) {\n return *this;\n }\n state_ = other.state_.load();\n release_func_ = std::move(other.release_func_);\n stream_ = std::move(other.stream_);\n stream_owner_ = other.stream_owner_.load();\n stream_pool_ = std::move(other.stream_pool_);\n\n other.state_ = State::UNSET;\n other.stream_owner_ = false;\n other.release_func_ = nullptr;\n return *this;\n }\n\n // callback function to release memory passed to the CudaBuffer\n using release_function_t = std::function (void* pointer)>;\n\n // Host callback function prototype\n using callback_function_t = void(*)(void*);\n\n static void CUDART_CB cudaHostCallback(void* buffer_ptr) {\n auto buffer = reinterpret_cast(buffer_ptr);\n GXF_LOG_VERBOSE(\"Received host callback from cuda stream for cuda buffer\");\n auto cb_registered = State::CALLBACK_REGISTERED;\n GXF_ASSERT_TRUE(buffer->state_.compare_exchange_strong(cb_registered, State::DATA_AVAILABLE));\n }\n\n Expected freeBuffer() {\n auto state = state_.load();\n // If another callback is already registered, buffer should not be freed\n GXF_ASSERT_NE(static_cast(state), static_cast(State::CALLBACK_REGISTERED));\n state_ = State::UNSET;\n if (release_func_ && pointer_) {\n const Expected result = release_func_(pointer_);\n if (!result) {\n return ForwardError(result);\n }\n release_func_ = nullptr;\n }\n\n return Success;\n }\n\n ~CudaBuffer() { freeBuffer(); }\n\n // Resizes the cuda buffer to given size on custom cuda stream. A new stream is allocated\n // from the stream pool if a pre allocated stream is not provided.\n Expected resizeAsync(Handle allocator,\n Handle stream_pool,\n uint64_t size,\n Handle stream_handle = Handle::Null()) {\n if (!allocator) {\n GXF_LOG_ERROR(\"Invalid cuda allocator provided while resizing a cuda buffer\");\n return Unexpected{GXF_ARGUMENT_INVALID};\n }\n\n if (!stream_pool) {\n GXF_LOG_ERROR(\"Invalid cuda stream pool provided while resizing a cuda buffer\");\n return Unexpected{GXF_ARGUMENT_INVALID};\n }\n\n const auto code = freeBuffer();\n if (!code) {\n GXF_LOG_ERROR(\"Failed to free memory. Error code: %s\", GxfResultStr(code.error()));\n return ForwardError(code);\n }\n\n // Allocate new stream if its not pre-allocated\n if (!stream_handle) {\n stream_handle = GXF_UNWRAP_OR_RETURN(stream_pool->allocateStream());\n }\n auto stream = GXF_UNWRAP_OR_RETURN(stream_handle->stream());\n auto result = GXF_UNWRAP_OR_RETURN(allocator->allocate_async(size, stream));\n\n GXF_LOG_VERBOSE(\"Registering callback for cuda buffer\");\n auto unset = State::UNSET;\n GXF_ASSERT_TRUE(state_.compare_exchange_strong(unset, State::CALLBACK_REGISTERED));\n cudaError_t cuda_result = cudaLaunchHostFunc(stream, cudaHostCallback, this);\n CHECK_CUDA_ERROR(cuda_result,\n \"Unable to register host function using cudaLaunchHostFunc\");\n\n storage_type_ = MemoryStorageType::kDevice;\n pointer_ = result;\n size_ = size;\n\n // TODO(chandrahasj) should allow custom stream to release the data ?\n release_func_ = [allocator, stream_pool, stream_handle, this] (void *data) {\n auto stream = stream_handle->stream().value();\n allocator->free_async(reinterpret_cast(data), stream);\n if (this->stream_owner_.load()) {\n // synchronize the stream before releasing it back into the pool\n auto code = cudaStreamSynchronize(stream_handle->stream().value());\n if (code != cudaSuccess) {\n GXF_LOG_ERROR(\"Failed to synchronize cuda stream\");\n return ExpectedOrCode(GXF_FAILURE);\n }\n return stream_pool->releaseStream(stream_handle);\n }\n return Success;\n };\n\n stream_ = stream_handle;\n stream_pool_ = stream_pool;\n return Success;\n }\n\n // Retrieves cuda buffer state\n State state() const { return state_.load(); }\n\n // Retrieves CudaStream\n Handle stream() {\n return stream_;\n }\n\n // Retrieves CudaStreamPool\n Handle streamPool() {\n return stream_pool_;\n }\n\n // Ownership of CudaStream is transferred to the caller.\n // Stream will not be released when this object is destroyed.\n Handle transferStreamOwnership() {\n stream_owner_ = false;\n return stream_;\n }\n\n // Register a host function callback on the cuda stream associated with the buffer\n Expected registerCallbackOnStream(callback_function_t func, void* data) {\n if (!stream_) {\n GXF_LOG_ERROR(\"CudaStream is not set for the CudaBuffer\");\n return Unexpected{GXF_FAILURE};\n }\n\n auto stream = GXF_UNWRAP_OR_RETURN(stream_->stream());\n GXF_LOG_VERBOSE(\"Registering callback for cuda buffer\");\n cudaError_t cuda_result = cudaLaunchHostFunc(stream, func, data);\n CHECK_CUDA_ERROR(cuda_result, \"Unable to register host function using cudaLaunchHostFunc\");\n return Success;\n }\n\n private:\n // State of the buffer\n std::atomic state_{State::UNSET};\n // Flag to keep track of shared ownership of the cuda stream\n std::atomic stream_owner_{true};\n // cuda host callback function on completion of all the queued work\n release_function_t release_func_ = nullptr;\n // CudaStream used to allocate memory for the cuda buffer\n Handle stream_ = Handle::Null();\n // CudaStreamPool used to allocate the CudaStream used by the buffer\n Handle stream_pool_ = Handle::Null();\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_CUDA_BUFFER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_common.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_CUDA_COMMON_HPP_\n#define NVIDIA_GXF_CUDA_CUDA_COMMON_HPP_\n\n#include \n\n#include \"common/assert.hpp\"\n#include \"common/logger.hpp\"\n\n#define CHECK_CUDA_ERROR(cu_result, fmt, ...) \\\n do { \\\n cudaError_t err = (cu_result); \\\n if (err != cudaSuccess) { \\\n GXF_LOG_ERROR(fmt \", cuda_error: %s, error_str: %s\", ##__VA_ARGS__, \\\n cudaGetErrorName(err), cudaGetErrorString(err)); \\\n return Unexpected{GXF_FAILURE}; \\\n } \\\n } while (0)\n\n#define CHECK_CUDA_ERROR_RESULT(cu_result, fmt, ...) \\\n do { \\\n cudaError_t err = (cu_result); \\\n if (err != cudaSuccess) { \\\n GXF_LOG_ERROR(fmt \", cuda_error: %s, error_str: %s\", ##__VA_ARGS__, \\\n cudaGetErrorName(err), cudaGetErrorString(err)); \\\n return GXF_FAILURE; \\\n } \\\n } while (0)\n\n#define CONTINUE_CUDA_ERROR(cu_result, fmt, ...) \\\n do { \\\n cudaError_t err = (cu_result); \\\n if (err != cudaSuccess) { \\\n GXF_LOG_ERROR(fmt \", cuda_error: %s, error_str: %s\", ##__VA_ARGS__, \\\n cudaGetErrorName(err), cudaGetErrorString(err)); \\\n } \\\n } while (0)\n\n#endif // NVIDIA_GXF_CUDA_CUDA_COMMON_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_event.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_CUDA_EVENT_HPP_\n#define NVIDIA_GXF_CUDA_CUDA_EVENT_HPP_\n\n#include \n\n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/handle.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nclass CudaStream;\n\n/**\n * @brief Holds and provides access to cudaEvent_t. The event could be set via initWithEvent() or\n * via created by init(flags, dev_id).\n */\nclass CudaEvent {\n public:\n CudaEvent() = default;\n ~CudaEvent();\n\n CudaEvent(const CudaEvent&) = delete;\n void operator=(const CudaEvent&) = delete;\n CudaEvent(CudaEvent&& other) {\n resetInternal();\n dev_id_ = other.dev_id_;\n other.dev_id_ = -1;\n event_ = std::move(other.event_);\n }\n void operator=(CudaEvent&& other) {\n resetInternal();\n dev_id_ = other.dev_id_;\n other.dev_id_ = -1;\n event_ = std::move(other.event_);\n }\n\n friend class CudaStream;\n\n using EventDestroy = std::function;\n\n // Initialize an external event that shall be used\n Expected initWithEvent(cudaEvent_t event, int dev_id = -1, EventDestroy free_fnc = nullptr);\n // Initialize a new event internally\n Expected init(uint32_t flags = 0, int dev_id = -1);\n // Deinitialize cudaevent. In case that user does not called it explicitly,\n // cuda event could be freed in destructor.\n Expected deinit();\n\n // Retrieves cuda event\n Expected event() const;\n // Get device id which owns this stream\n int dev_id() const { return dev_id_; }\n\n private:\n template\n using PtrT = std::unique_ptr>;\n using EventPtr = PtrT;\n\n void resetInternal();\n\n static Expected createEventInternal(uint32_t flags, int gpuid);\n static Expected createEventInternal(\n cudaEvent_t event, EventDestroy free_event);\n\n int32_t dev_id_ = -1;\n EventPtr event_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_CUDA_EVENT_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_scheduling_terms.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_CUDA_SCHEDULING_TERMS_HPP_\n#define NVIDIA_GXF_CUDA_CUDA_SCHEDULING_TERMS_HPP_\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/core/parameter_registrar.hpp\"\n#include \"gxf/cuda/cuda_common.hpp\"\n#include \"gxf/cuda/cuda_event.hpp\"\n#include \"gxf/cuda/cuda_stream_id.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/scheduling_term.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief Scheduling term to monitor activity on a cuda stream\n *\n * A component which specifies the availability of data at the receiver on completion of\n * the work on the provided cuda stream with the help of callback function to host.\n * This scheduling term will register a call back function which will be called once the work on the\n * specified cuda stream completes indicating that the data is available for consumption\n */\nclass CudaStreamSchedulingTerm : public SchedulingTerm {\n public:\n // state of the scheduling term\n enum class State : int8_t {\n UNSET = 0, // Initial state not waiting for any cuda host callback\n CALLBACK_REGISTERED, // Indicates a call back function is registered\n DATA_AVAILABLE, // Indicates data is ready to be consumed\n };\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n private:\n // Receiver to monitor cuda stream activity\n Parameter> receiver_;\n // The current state of the scheduling term\n SchedulingConditionType current_state_;\n // Current message entity being monitored\n std::atomic message_eid_ = kNullUid;\n // State of the scheduling term\n std::atomic state_{State::UNSET};\n // cuda host callback function on completion of all the queued work\n static void CUDART_CB cudaHostCallback(void* term_ptr);\n};\n\n/**\n * @brief Scheduling term based on cuda event\n *\n * A component which specifies the availability of data at the receiver on completion of the\n * work on the provided cuda stream with the help of cuda event.\n * This scheduling term will keep polling on the event provided to check for data availability for\n * consumption.\n */\nclass CudaEventSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n private:\n Parameter> receiver_;\n Parameter event_name_{};\n SchedulingConditionType current_state_; // The current state of the scheduling term\n int64_t last_state_change_; // timestamp when the state changed the last time\n};\n\n\n/**\n * @brief Scheduling term based on data availability in a cuda buffer\n *\n * A component which specifies the availability of data at the receiver based on\n * the cuda buffers present in incoming messages.\n */\nclass CudaBufferAvailableSchedulingTerm : public SchedulingTerm {\n public:\n // state of the scheduling term\n enum class State : int8_t {\n UNSET = 0, // Initial state not waiting for any cuda host callback\n CALLBACK_REGISTERED, // Indicates a call back function is registered\n DATA_AVAILABLE, // Indicates data is ready to be consumed\n };\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n private:\n // Receiver to monitor cuda stream activity\n Parameter> receiver_;\n // The current state of the scheduling term\n SchedulingConditionType current_state_;\n // Current message entity being monitored\n std::atomic message_eid_ = kNullUid;\n // State of the scheduling term\n std::atomic state_{State::UNSET};\n // timestamp when the state changed the last time\n int64_t last_state_change_;\n // cuda host callback function on completion of all the queued work\n static void CUDART_CB cudaHostCallback(void* term_ptr);\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_CUDA_SCHEDULING_TERMS_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_CUDA_STREAM_HPP_\n#define NVIDIA_GXF_CUDA_CUDA_STREAM_HPP_\n\n#include \"cuda.h\"\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/cuda/cuda_event.hpp\"\n\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief Holds and provides access to cudaStream_t. CudaStream is allocated and\n * recycled by CudaStreamPool\n */\nclass CudaStream {\n public:\n CudaStream() = default;\n ~CudaStream();\n\n CudaStream(const CudaStream&) = delete;\n CudaStream(CudaStream&&) = delete;\n void operator=(const CudaStream&) = delete;\n\n using EventDestroy = std::function;\n using SyncedCallback = std::function;\n\n // Retrieves cudaSteam_t\n Expected stream() const;\n // Get device id which owns this stream\n int dev_id() const { return dev_id_; }\n\n // Record event to extend Entity life until event synchronized.\n Expected record(Handle event, Entity input_entity,\n SyncedCallback synced_cb = nullptr);\n // Record event on the stream for an async callback.\n // The callback would be delayed until CudaStreamSync ticks.\n // The Callback usually is used to recycle dependent resources.\n // If record failed, callback would not be called. User need to check return results.\n Expected record(cudaEvent_t event, EventDestroy cb);\n\n // Reset all events and callback all the hook functions to release resource.\n Expected resetEvents();\n\n // Sync all streams, meanwhile clean all recorded events and callback recycle functions\n Expected syncStream();\n\n private:\n friend class CudaStreamPool;\n // Initialize new cuda stream if was not set by external\n Expected initialize(const std::string& nvtxIdentifier, uint32_t flags = 0, int dev_id = -1,\n int32_t priority = 0, CUgreenCtx green_ctx = nullptr);\n Expected deinitialize();\n\n Expected prepareResourceInternal(int dev_id);\n\n Expected recordEventInternal(cudaEvent_t e);\n Expected syncEventInternal(cudaEvent_t e);\n\n Expected resetEventsInternal(std::queue& q);\n\n gxf_result_t loadDriverFunctions();\n\n mutable std::shared_timed_mutex mutex_;\n int dev_id_ = 0;\n cudaStream_t stream_ = 0;\n\n // store all recorded event with destroy functions.\n std::queue recorded_event_queue_;\n // event is defined for for synchronization of stream\n CudaEvent::EventPtr sync_event_;\n\n // Function to create green context stream\n CUresult (*fnCuGreenCtxStreamCreate)(CUstream*, CUgreenCtx, unsigned int, int32_t) = nullptr;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_CUDA_STREAM_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_id.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_CUDA_STREAM_ID_HPP_\n#define NVIDIA_GXF_CUDA_CUDA_STREAM_ID_HPP_\n\n#include \"gxf/core/gxf.h\"\n\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief The Structure indicates cuda stream component ID.\n *\n * Message entity carrying CudaStreamId indicates that Tensors will be or\n * has been processed by corresponding cuda stream. The handle could\n * be deduced by Handle::Create(context, stream_cid).\n */\nstruct CudaStreamId {\n // component id of CudaStream\n gxf_uid_t stream_cid;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_CUDA_STREAM_ID_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_pool.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_CUDA_STREAM_POOL_HPP_\n#define NVIDIA_GXF_CUDA_CUDA_STREAM_POOL_HPP_\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/cuda/cuda_stream.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/cuda_green_context.hpp\"\n#include \"gxf/std/resources.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief A stream pool containing a specified number of CUDA streams on a single device.\n */\nclass CudaStreamPool : public Allocator {\n public:\n CudaStreamPool() = default;\n ~CudaStreamPool();\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t is_available_abi(uint64_t size) override;\n gxf_result_t allocate_abi(uint64_t size, int32_t type, void** pointer) override;\n gxf_result_t free_abi(void* pointer) override;\n gxf_result_t deinitialize() override;\n\n // Allocate a cudastream for other components\n Expected> allocateStream();\n // Free a cudastream\n Expected releaseStream(Handle stream);\n\n private:\n Expected createNewStreamEntity(const std::string& nvtx_identifier);\n Expected reserveStreams();\n\n Resource> gpu_device_;\n Parameter stream_flags_;\n Parameter stream_priority_;\n Parameter reserved_size_;\n Parameter max_size_;\n Parameter nvtx_identifier_;\n Parameter> cuda_green_context_;\n\n std::mutex mutex_;\n // map of \n std::unordered_map> streams_;\n std::queue reserved_streams_;\n CUgreenCtx green_ctx_ = nullptr;\n std::atomic stage_{AllocatorStage::kUninitialized};\n int32_t dev_id_ = -1;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_CUDA_STREAM_POOL_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_sync.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_CUDA_STREAM_SYNC_HPP_\n#define NVIDIA_GXF_CUDA_CUDA_STREAM_SYNC_HPP_\n\n#include \n\n#include \"gxf/cuda/cuda_stream.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief Get all cuda streams from messages of receiver, synchronize these streams,\n * and forward messages to transmitter.\n */\nclass CudaStreamSync : public Codelet {\n public:\n virtual ~CudaStreamSync() = default;\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t tick() override;\n\n private:\n Parameter> rx_;\n Parameter> tx_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_CUDA_STREAM_SYNC_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/stream_ordered_allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STREAM_ORDERED_ALLOCATOR_HPP_\n#define NVIDIA_GXF_STREAM_ORDERED_ALLOCATOR_HPP_\n\n#include \n#include \n\n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"common/logger.hpp\"\n#include \"gxf/core/parameter.hpp\"\n#include \"gxf/cuda/cuda_allocator.hpp\"\n#include \"gxf/std/resources.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief An allocator which allocates and frees device memory using a CUDA memory pool.\n *\n * It uses CUDA's Stream Ordered Memory Allocator (cudaMallocFromPoolAsync/cudaFreeAsync).\n * For synchronous allocate and free, it uses its own internally created CUDA stream.\n * For asynchronous allocate and free, the user provided stream is used.\n */\nclass StreamOrderedAllocator : public CudaAllocator {\n public:\n StreamOrderedAllocator() = default;\n ~StreamOrderedAllocator() = default;\n\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t is_available_abi(uint64_t size) override;\n gxf_result_t allocate_abi(uint64_t size, int32_t storage_type, void** pointer) override;\n gxf_result_t allocate_async_abi(uint64_t size, void** pointer,\n cudaStream_t stream) override;\n gxf_result_t free_async_abi(void* pointer, cudaStream_t stream) override;\n gxf_result_t free_abi(void* pointer) override;\n\n Expected get_pool_size(MemoryStorageType type) const override;\n\n private:\n Resource> gpu_device_;\n Parameter release_threshold_;\n Parameter device_memory_initial_size_;\n Parameter device_memory_max_size_;\n\n mutable std::shared_mutex shared_mutex_;\n std::unordered_map pool_map_;\n\n AllocatorStage stage_{AllocatorStage::kUninitialized};\n cudaStream_t stream_;\n cudaMemPool_t memory_pool_;\n cudaMemPoolProps pool_props_ = {};\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STREAM_ORDERED_ALLOCATOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/tests/convolution.h", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_TESTS_CONVOLUTION_HPP\n#define NVIDIA_GXF_CUDA_TESTS_CONVOLUTION_HPP\n\n#include \n\n#define THREADS_PER_BLOCK 32\n#define THREADS_PER_BLOCK_1 (THREADS_PER_BLOCK - 1)\n\n// A simple GPU based 2d convolution operation\nextern \"C\" void convolveKernel(float *input, float *kernel,\n float *output, int width, int height,\n int kernelSize, cudaStream_t stream);\n\n#endif // NVIDIA_GXF_CUDA_TESTS_CONVOLUTION_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/tests/green_context_with_smid.h", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_CUDA_TESTS_GREEN_CONTEXT_WITH_SMID_HPP\n#define NVIDIA_GXF_CUDA_TESTS_GREEN_CONTEXT_WITH_SMID_HPP\n\n#include \n#include \n\n#include \n#include \n\n#define THREADS_PER_BLOCK 32\n#define THREADS_PER_BLOCK_1 (THREADS_PER_BLOCK - 1)\n\n// Structure to hold thread information including SMID\nstruct SmidThreadInfo {\n int thread_id; // Global thread index\n int block_id; // Block index\n int thread_in_block; // Thread index within block\n uint32_t smid; // Streaming Multiprocessor ID\n int block_dim_x; // Block dimension x\n int grid_dim_x; // Grid dimension x\n};\n\n// CUDA kernel function declarations\nextern \"C\" {\n // Main function to test SMID for every thread\n void test_every_thread_smid(int num_blocks, int threads_per_block, cudaStream_t stream, SmidThreadInfo* h_thread_info);\n\n // Function to analyze SMID results\n int32_t analyze_smid_results(std::vector ptr_thread_info, int threads_per_block, int num_blocks, int num_streams);\n\n // Function to test SMID with different configurations\n int32_t test_smid_with_different_configurations(cudaStream_t* streams, int num_streams);\n\n // Function to collect SM IDs from a single kernel launch\n int32_t collect_smid_from_kernel(int num_blocks, int threads_per_block, cudaStream_t stream, std::set& unique_smids);\n}\n\n#endif // NVIDIA_GXF_CUDA_TESTS_GREEN_CONTEXT_WITH_SMID_HPP" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/tests/test_cuda_helper.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CUDA_TESTS_TEST_CUDA_HELPER_HPP\n#define NVIDIA_GXF_CUDA_TESTS_TEST_CUDA_HELPER_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"convolution.h\"\n#include \"green_context_with_smid.h\"\n\n#include \"common/assert.hpp\"\n#include \"gxf/cuda/cuda_buffer.hpp\"\n#include \"gxf/cuda/cuda_common.hpp\"\n#include \"gxf/cuda/cuda_event.hpp\"\n#include \"gxf/cuda/cuda_stream.hpp\"\n#include \"gxf/cuda/cuda_stream_id.hpp\"\n#include \"gxf/cuda/cuda_stream_pool.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/tensor.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\n#define CHECK_CUBLUS_ERROR(cu_result, fmt, ...) \\\n do { \\\n cublasStatus_t err = (cu_result); \\\n if (err != CUBLAS_STATUS_SUCCESS) { \\\n GXF_LOG_ERROR(fmt \", cublas_error: %d\", ##__VA_ARGS__, (int)err); \\\n return Unexpected{GXF_FAILURE}; \\\n } \\\n } while (0)\n\nnamespace nvidia {\nnamespace gxf {\nnamespace test {\nnamespace cuda {\n\nconstexpr static const char* kStreamName0 = \"CudaStream0\";\nconstexpr static int kDefaultDevId = 0;\nstatic const Shape kInitTensorShape{1024, 2048};\n\n// The base class with cuda stream utils\nclass StreamBasedOps : public Codelet {\n public:\n static Expected> getStream(Entity& message) {\n auto stream_id = message.get();\n GXF_ASSERT(stream_id, \"failed to find cudastreamid\");\n auto stream =\n Handle::Create(stream_id.value().context(), stream_id.value()->stream_cid);\n GXF_ASSERT(stream, \"create cudastream from cid failed\");\n GXF_ASSERT(stream.value(), \"cudastream handle is null\");\n return stream;\n }\n\n static Expected addStream(Entity& message, Handle& stream,\n const char* name = nullptr) {\n auto stream_id = message.add(name);\n GXF_ASSERT(stream_id, \"failed to add cudastreamid\");\n stream_id.value()->stream_cid = stream.cid();\n GXF_ASSERT(stream_id.value()->stream_cid != kNullUid, \"stream_cid is null\");\n return Success;\n }\n\n static Expected> addTensor(Entity& message, Handle pool,\n const TensorDescription& description) {\n GXF_ASSERT(pool, \"pool is not set\");\n auto tensor = message.add(description.name.c_str());\n GXF_ASSERT(tensor, \"failed to add message tensor\");\n const uint64_t bytes_per_element = description.element_type == PrimitiveType::kCustom\n ? description.bytes_per_element\n : PrimitiveTypeSize(description.element_type);\n\n auto result = tensor.value()->reshapeCustom(description.shape, description.element_type,\n bytes_per_element, description.strides,\n description.storage_type, pool);\n GXF_ASSERT(result, \"reshape tensor:%s failed\", description.name.c_str());\n return tensor;\n }\n\n Expected> addNewEvent(Entity& message, const char* name = nullptr) const {\n GXF_ASSERT(opsEvent(), \"cuda stream ops event is not initialized\");\n\n auto mabe_event = message.add(name);\n GXF_ASSERT(mabe_event, \"failed to add cudaevent\");\n auto& event = mabe_event.value();\n auto ret = event->initWithEvent(ops_event_->event().value(), ops_event_->dev_id());\n GXF_ASSERT(ret, \"failed to init with event into message\");\n GXF_ASSERT(event->event(), \"stream_cid is null\");\n return mabe_event;\n }\n\n Expected initOpsEvent() {\n if (ops_event_) { return Success; }\n auto ops_event_entity = Entity::New(context());\n GXF_ASSERT(ops_event_entity, \"New event entity failed\");\n ops_event_holder_ = ops_event_entity.value();\n auto maybe_event = ops_event_holder_.add(\"ops_event\");\n GXF_ASSERT(maybe_event, \"failed to init ops cudaevent\");\n ops_event_ = maybe_event.value();\n auto ret = ops_event_->init(0, kDefaultDevId);\n if (!ret) {\n GXF_LOG_ERROR(\"failed to init Ops event\");\n return ForwardError(ret);\n }\n return ret;\n }\n\n const Handle& opsEvent() const { return ops_event_; }\n\n private:\n Handle ops_event_;\n Entity ops_event_holder_;\n};\n\n// Generate cuda tensor map with cudastreams for transmitter cuda_tx,\n// Generate host tensor map for transmitter host_tx\nclass StreamTensorGenerator : public StreamBasedOps {\n public:\n gxf_result_t initialize() override {\n GXF_ASSERT(stream_pool_.get(), \"stream pool is not set\");\n auto stream = stream_pool_->allocateStream();\n GXF_ASSERT(stream, \"allocating stream failed\");\n stream_ = std::move(stream.value());\n GXF_ASSERT(stream_->stream(), \"allocated stream is not initialized.\");\n return GXF_SUCCESS;\n }\n\n gxf_result_t deinitialize() override {\n auto result = stream_pool_->releaseStream(stream_);\n return ToResultCode(result);\n }\n\n gxf_result_t tick() override {\n Expected maybe_dev_msg = Entity::New(context());\n GXF_ASSERT(maybe_dev_msg, \"New dev message failed\");\n auto& dev_msg = maybe_dev_msg.value();\n\n Expected maybe_host_msg = Entity::New(context());\n GXF_ASSERT(maybe_host_msg, \"New host message failed\");\n auto& host_msg = maybe_host_msg.value();\n\n auto ret = createTensors(dev_msg, host_msg);\n GXF_ASSERT(ret, \"creating tensors failed\");\n GXF_ASSERT(stream_, \"stream is not allocated\");\n\n ret = addStream(dev_msg, stream_, kStreamName0);\n GXF_ASSERT(ret, \"stream tensor generator adding stream failed\");\n\n ret = cuda_tx_->publish(dev_msg);\n if (!ret) {\n GXF_LOG_ERROR(\"stream tensor generator publishing cuda tensors failed\");\n return ToResultCode(ret);\n }\n\n if (host_tx_.get()) {\n ret = host_tx_->publish(host_msg);\n if (!ret) {\n GXF_LOG_ERROR(\"stream tensor generator publishing cuda tensors failed\");\n return ToResultCode(ret);\n }\n }\n\n return GXF_SUCCESS;\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(cuda_tx_, \"cuda_tx\", \"transmitter of cuda tensors\", \"\");\n result &= registrar->parameter(host_tx_, \"host_tx\", \"transmitter of host tensors\", \"\",\n Handle());\n result &= registrar->parameter(cuda_tensor_pool_, \"cuda_tensor_pool\", \"Cuda Tensor Pool\", \"\");\n result &= registrar->parameter(host_tensor_pool_, \"host_tensor_pool\", \"Host Tensor Pool\", \"\");\n result &= registrar->parameter(stream_pool_, \"stream_pool\", \"Cuda Stream Pool\", \"\");\n return ToResultCode(result);\n }\n\n private:\n Expected createTensors(Entity& dev_msg, Entity& host_msg) {\n Shape shape = kInitTensorShape;\n for (size_t i = 0; i < 2; ++i) {\n TensorDescription dev_desc{\"cuda_tensor\", MemoryStorageType::kDevice, shape,\n PrimitiveType::kFloat32};\n auto cuda_tensor_ret = addTensor(dev_msg, cuda_tensor_pool_, dev_desc);\n GXF_ASSERT(cuda_tensor_ret, \"Generator dev message adding tensor failed.\");\n auto& cuda_tensor = cuda_tensor_ret.value();\n Expected cuda_data = cuda_tensor->data();\n if (!cuda_data) { return ForwardError(cuda_data); }\n\n TensorDescription host_desc{\"host_tensor\", MemoryStorageType::kHost, shape,\n PrimitiveType::kFloat32};\n auto host_tensor_ret = addTensor(host_msg, host_tensor_pool_, host_desc);\n GXF_ASSERT(host_tensor_ret, \"Generator host message adding tensor failed.\");\n auto& host_tensor = host_tensor_ret.value();\n Expected host_data = host_tensor->data();\n if (!host_data) { return ForwardError(host_data); }\n\n for (size_t j = 0; j < shape.size(); ++j) {\n host_data.value()[j] = (j % 100) + 1.0f;\n }\n\n cudaError_t error = cudaMemcpy(cuda_data.value(), host_data.value(), cuda_tensor->size(),\n cudaMemcpyHostToDevice);\n CHECK_CUDA_ERROR(error, \"StreamTensorGenerator cuda memory cpy H2D failed.\");\n }\n\n return Success;\n }\n\n Parameter> cuda_tx_;\n Parameter> host_tx_;\n Parameter> cuda_tensor_pool_;\n Parameter> host_tensor_pool_;\n Parameter> stream_pool_;\n\n Handle stream_;\n};\n\n// Dot product execution base class\nclass DotProductExe {\n private:\n Handle rx_;\n Handle tx_;\n Handle tensor_pool_;\n\n public:\n DotProductExe() = default;\n virtual ~DotProductExe() = default;\n void setEnv(const Handle& rx, const Handle& tx,\n const Handle& pool) {\n rx_ = rx;\n tx_ = tx;\n tensor_pool_ = pool;\n }\n\n virtual Expected dotproduct_i(float* in0, float* in1, float* out, int32_t row,\n int32_t column, Entity& in_msg, Entity& out_msg) = 0;\n\n Expected execute(const char* out_tensor_name = \"\") {\n GXF_ASSERT(rx_ && tx_ && tensor_pool_, \"dotproduct received empty in_msg\");\n\n Expected in_msg = rx_->receive();\n GXF_ASSERT(in_msg, \"dotproduct received empty in_msg\");\n\n // get tensors\n auto in_tensors = in_msg->findAll();\n GXF_ASSERT(in_tensors, \"failed to find Tensors in in_msg\");\n GXF_ASSERT(in_tensors->size() == 2, \"doesn't find Tensors in in_msg\");\n GXF_ASSERT(in_tensors->at(0).value()->rank() == 2, \"Input tensor rank is not 2\");\n int32_t column = in_tensors->at(0).value()->shape().dimension(1);\n int32_t row = in_tensors->at(0).value()->shape().dimension(0);\n MemoryStorageType mem_type = in_tensors->at(0).value()->storage_type();\n PrimitiveType data_type = in_tensors->at(0).value()->element_type();\n float* in_data[2] = {nullptr};\n for (size_t i = 0; i < in_tensors->size(); ++i) {\n GXF_ASSERT(in_tensors->at(i).value(), \"Input Tensor Handle is empty\");\n GXF_ASSERT(in_tensors->at(i).value()->rank() == 2, \"Input tensor rank is not 2\");\n in_data[i] = ValuePointer(in_tensors->at(i).value()->pointer());\n }\n\n Expected output = Entity::New(in_msg->context());\n GXF_ASSERT(output, \"Creating dotproduct output tensor failed.\");\n Shape out_shape{row};\n GXF_ASSERT(out_shape.rank() == 1 && out_shape.size() == static_cast(row),\n \"output_shape is not correct\");\n TensorDescription outDesc{out_tensor_name, mem_type, out_shape, data_type};\n auto out_tensor = StreamBasedOps::addTensor(output.value(), tensor_pool_, outDesc);\n GXF_ASSERT(out_tensor && out_tensor.value(), \"cuda dotproduct output tensor is not found\");\n float* out_data = ValuePointer(out_tensor.value()->pointer());\n\n auto ret =\n dotproduct_i(in_data[0], in_data[1], out_data, row, column, in_msg.value(), output.value());\n GXF_ASSERT(ret, \"dotproduct execute with implementation failed\");\n\n ret = tx_->publish(output.value());\n GXF_ASSERT(ret, \"dotproduct publishing tensors failed\");\n return ret;\n }\n};\n\n// Cublas Dot product Operators\nclass CublasDotProduct : public StreamBasedOps {\n public:\n // Culblas dot production execution class\n class CublasDotProductExe : public DotProductExe {\n private:\n cublasHandle_t handle_ = nullptr;\n CublasDotProduct* codelet_ = nullptr;\n\n public:\n CublasDotProductExe(CublasDotProduct* codelet) : codelet_(codelet) {}\n ~CublasDotProductExe() {\n if (handle_) { cublasDestroy(handle_); }\n }\n Expected dotproduct_i(float* in0, float* in1, float* out, int32_t row, int32_t column,\n Entity& in_msg, Entity& out_msg) override {\n // locate stream\n auto maybe_stream = StreamBasedOps::getStream(in_msg);\n GXF_ASSERT(maybe_stream && maybe_stream.value(), \"get stream from in_msg failed\");\n auto& stream = maybe_stream.value();\n auto ret = StreamBasedOps::addStream(out_msg, stream);\n GXF_ASSERT(ret, \"adding cudastream into dotproduct output message failed.\");\n\n int gpu_id = stream->dev_id();\n if (gpu_id >= 0) {\n CHECK_CUDA_ERROR(cudaSetDevice(gpu_id), \"failed to set deviceid: %d\", gpu_id);\n }\n\n if (!handle_) {\n CHECK_CUBLUS_ERROR(cublasCreate(&handle_), \"failed to create cublas handle\");\n }\n auto custream_id = stream->stream();\n GXF_ASSERT(custream_id, \"cudastream id is invalid\");\n CHECK_CUBLUS_ERROR(cublasSetStream(handle_, custream_id.value()), \"cublas set stream failed\");\n\n for (int i = 0; i < row; ++i) {\n CHECK_CUBLUS_ERROR(\n cublasSdot(handle_, column, in0 + column * i, 1, in1 + column * i, 1, out + i),\n \"cublasSdot failed on row :%d\", i);\n }\n\n auto maybe_event = codelet_->addNewEvent(out_msg, \"cudotproduct_event\");\n GXF_ASSERT(maybe_event, \"failed to add cublas dot product event\");\n // Recording this event here causes a leak\n // ret = stream->record(maybe_event.value(), in_msg,\n // []() { GXF_LOG_ERROR(\"cublas dotproduct event synced\"); });\n // GXF_ASSERT(ret, \"cublas dotproduct record event failed\");\n return ret;\n }\n };\n\n CublasDotProduct() : exec_(this) {}\n\n gxf_result_t initialize() override {\n GXF_ASSERT(tensor_pool_.get() && rx_.get() && tx_.get(), \"params not set\");\n exec_.setEnv(rx_.get(), tx_.get(), tensor_pool_.get());\n return GXF_SUCCESS;\n }\n\n gxf_result_t start() override { return ToResultCode(initOpsEvent()); }\n\n gxf_result_t tick() override {\n auto ret = exec_.execute(\"cublasdotproduct_tensor\");\n return ToResultCode(ret);\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(tx_, \"tx\", \"transmitter of tensors\", \"\");\n result &= registrar->parameter(rx_, \"rx\", \"receiver of tensors\", \"\");\n result &= registrar->parameter(tensor_pool_, \"tensor_pool\", \"Tensor Pool\", \"\");\n return ToResultCode(result);\n }\n\n private:\n Parameter> tx_;\n Parameter> rx_;\n Parameter> tensor_pool_;\n\n CublasDotProductExe exec_;\n};\n\n// CPU Dot product Operators\nclass HostDotProduct : public Codelet {\n public:\n // CPU dot production execution class\n class HostDotProductExe : public DotProductExe {\n public:\n HostDotProductExe() = default;\n ~HostDotProductExe() = default;\n Expected dotproduct_i(float* in0, float* in1, float* out, int32_t row, int32_t column,\n Entity& in_msg, Entity& out_msg) override {\n for (int i = 0; i < row; ++i) {\n float sum = 0.0;\n float* x = in0 + column * i;\n float* y = in1 + column * i;\n for (int j = 0; j < column; ++j) { sum += x[j] * y[j]; }\n out[i] = sum;\n }\n return Success;\n }\n };\n\n gxf_result_t initialize() override {\n GXF_ASSERT(tensor_pool_.get() && rx_.get() && tx_.get(), \"params not set\");\n exec_.setEnv(rx_.get(), tx_.get(), tensor_pool_.get());\n return GXF_SUCCESS;\n }\n\n gxf_result_t tick() override {\n auto ret = exec_.execute(\"host_dotproduct_tensor\");\n return ToResultCode(ret);\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(tx_, \"tx\", \"transmitter of tensors\", \"\");\n result &= registrar->parameter(rx_, \"rx\", \"receiver of tensors\", \"\");\n result &= registrar->parameter(tensor_pool_, \"tensor_pool\", \"Tensor Pool\", \"\");\n return ToResultCode(result);\n }\n\n private:\n Parameter> tx_;\n Parameter> rx_;\n Parameter> tensor_pool_;\n\n HostDotProductExe exec_;\n};\n\n// Stream based Memory copy from device to host\nclass MemCpy2Host : public StreamBasedOps {\n public:\n gxf_result_t start() override { return ToResultCode(initOpsEvent()); }\n\n gxf_result_t tick() override {\n auto in = rx_->receive();\n GXF_ASSERT(in, \"rx received empty message\");\n auto maybe_tensor = in.value().get();\n GXF_ASSERT(maybe_tensor, \"tensor not found\");\n auto& in_tensor = maybe_tensor.value();\n byte* in_data = in_tensor->pointer();\n\n Expected out_msg = Entity::New(context());\n TensorDescription out_desc{in_tensor.name(), MemoryStorageType::kHost, in_tensor->shape(),\n in_tensor->element_type()};\n auto maybe_out_tensor = addTensor(out_msg.value(), tensor_pool_, out_desc);\n GXF_ASSERT(maybe_out_tensor, \"Memcpy host message adding tensor failed.\");\n auto& out_tensor = maybe_out_tensor.value();\n byte* out_data = out_tensor->pointer();\n\n auto maybe_stream = getStream(in.value());\n GXF_ASSERT(maybe_stream && maybe_stream.value(), \"get stream from in failed\");\n auto& stream = maybe_stream.value();\n auto ret = addStream(out_msg.value(), stream);\n GXF_ASSERT(ret, \"adding cudastream into memcpy output message failed.\");\n\n // wrap cuda operations since CHECK_CUDA_ERROR return Expected\n ret = [&, this]() -> Expected {\n int gpu_id = stream->dev_id();\n if (gpu_id >= 0) {\n CHECK_CUDA_ERROR(cudaSetDevice(gpu_id), \"failed to set deviceid: %d\", gpu_id);\n }\n cudaError_t error = cudaMemcpyAsync(out_data, in_data, in_tensor->size(),\n cudaMemcpyDeviceToHost, stream->stream().value());\n CHECK_CUDA_ERROR(error, \"CUDA memory cpy to host failed.\");\n return Success;\n }();\n GXF_ASSERT(ret, \"CUDA memory cpy to host failed.\");\n\n auto maybe_event = addNewEvent(out_msg.value(), \"memcpy_event\");\n GXF_ASSERT(maybe_event, \"failed to add memcpy_event\");\n // Recording this event here causes a leak\n // ret = stream->record(maybe_event.value(), in.value(),\n // []() { GXF_LOG_ERROR(\"memcpy_to_host event synced\"); });\n // GXF_ASSERT(ret, \"memcpy_to_host record event failed\");\n\n ret = tx_->publish(out_msg.value());\n GXF_ASSERT(ret, \"memcpy_to_host publishing tensors failed\");\n\n return ToResultCode(ret);\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(tx_, \"tx\", \"transmitter of tensors\", \"\");\n result &= registrar->parameter(rx_, \"rx\", \"receiver of tensors\", \"\");\n result &= registrar->parameter(tensor_pool_, \"tensor_pool\", \"Tensor output pool\", \"\");\n return ToResultCode(result);\n }\n\n private:\n Parameter> tx_;\n Parameter> rx_;\n Parameter> tensor_pool_;\n};\n\n// Equal verification\nclass VerifyEqual : public Codelet {\n public:\n gxf_result_t tick() override {\n GXF_LOG_DEBUG(\"verifying frame: %d\", count_++);\n auto in0 = rx0_->receive();\n GXF_ASSERT(in0, \"rx0 received empty message\");\n auto in1 = rx1_->receive();\n GXF_ASSERT(in1, \"rx1 received empty message\");\n\n // get tensors\n auto maybe_tensor0 = in0.value().get();\n GXF_ASSERT(maybe_tensor0, \"tensor0 not found\");\n auto maybe_tensor1 = in1.value().get();\n GXF_ASSERT(maybe_tensor1, \"tensor1 not found\");\n auto& tensor0 = maybe_tensor0.value();\n auto& tensor1 = maybe_tensor1.value();\n GXF_ASSERT(std::string(tensor0.name()) != std::string(tensor1.name()),\n \"2 tensor name should not same\");\n GXF_ASSERT(tensor0->shape() == tensor1->shape(), \"2 tensors' shape not matched\");\n GXF_ASSERT(tensor0->element_type() == tensor1->element_type(),\n \"2 tensor's element type not matched\");\n GXF_ASSERT(tensor0->storage_type() == tensor1->storage_type(),\n \"2 tensor's storage_type not matched\");\n GXF_ASSERT(tensor0->storage_type() == MemoryStorageType::kHost,\n \"very tensor storage_type is not from host\");\n\n float* data0 = tensor0->data().value();\n float* data1 = tensor1->data().value();\n uint64_t count = tensor0->element_count();\n for (uint64_t i = 0; i < count; ++i) {\n // printf(\"i:%d, [%f], [%f]\\n\", static_cast(i), data0[i], data1[i]);\n GXF_ASSERT(fequal(data0[i], data1[i]), \"data0[%d]: %f but data1: %f.\", static_cast(i),\n data0[i], data1[i]);\n }\n\n return GXF_SUCCESS;\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(rx0_, \"rx0\", \"receiver0 of tensors\", \"\");\n result &= registrar->parameter(rx1_, \"rx1\", \"receiver1 of tensors\", \"\");\n return ToResultCode(result);\n }\n\n private:\n bool fequal(float a, float b) {\n if (fabs(a - b) <= std::numeric_limits::epsilon()) return true;\n return false;\n }\n Parameter> rx0_;\n Parameter> rx1_;\n int32_t count_ = 0;\n};\n\n// Creates a CudaBuffer object on each iteration with memory allocated in an\n// asynchronous manner. Downstream receivers can either enqueue more work on to\n// CudaStream associated with the CudaBuffer or sync on the stream before accessing the memory\nclass CudaAsyncBufferGenerator : public Codelet {\n public:\n virtual ~CudaAsyncBufferGenerator() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(signal_, \"signal\", \"Signal\",\n \"Transmitter channel publishing messages to other graph entities\");\n result &= registrar->parameter(allocator_, \"allocator\", \"Allocator\",\n \"A cuda allocator component that can serve device memory asynchronously\");\n result &= registrar->parameter(stream_pool_, \"stream_pool\", \"StreamPool\",\n \"A cuda stream pool component\");\n result &= registrar->parameter(size_, \"size\", \"Size\",\n \"Size of the CudaBuffer to be allocated\", 1UL);\n return ToResultCode(result);\n }\n\n gxf_result_t tick() override {\n auto maybe_message = Entity::New(context());\n if (!maybe_message) {\n GXF_LOG_ERROR(\"Failure creating message entity.\");\n return maybe_message.error();\n }\n\n auto message = maybe_message.value();\n auto maybe_buffer = message.add(kDefaultCudaBufferName);\n if (!maybe_buffer) {\n GXF_LOG_ERROR(\"Failure creating cuda buffer\");\n return maybe_buffer.error();\n }\n\n auto buffer = maybe_buffer.value();\n auto code = buffer->resizeAsync(allocator_, stream_pool_, size_);\n\n auto min = std::numeric_limits::min();\n auto max = std::numeric_limits::max();\n std::uniform_real_distribution distribution(min, max);\n std::vector elements;\n auto element_count = size_ / sizeof(float);\n\n for (size_t idx = 0; idx < element_count; idx++) {\n elements.push_back(distribution(generator_));\n }\n\n auto stream_component = buffer->stream();\n auto stream = stream_component->stream().value();\n\n const cudaError_t error = cudaMemcpyAsync(buffer->pointer(), elements.data(),\n size_, cudaMemcpyHostToDevice, stream);\n CHECK_CUDA_ERROR_RESULT(error, \"cudaMemcpyAsync failed\");\n\n auto result = signal_->publish(message);\n GXF_LOG_INFO(\"Message Sent\");\n return GXF_SUCCESS;\n }\n\n private:\n Parameter> signal_;\n Parameter> allocator_;\n Parameter> stream_pool_;\n Parameter size_;\n std::default_random_engine generator_;\n};\n\n// Performs a green context test with detection of different SMIDs\nclass GreenContextWithSmid: public Codelet {\n public:\n virtual ~GreenContextWithSmid() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(stream_pools_, \"stream_pools\", \"StreamPools\",\n \"A cuda stream pool component\");\n result &= registrar->parameter(num_stream_pools_, \"num_stream_pools\", \"NumStreamPools\",\n \"Number of streams to allocate\", 1);\n result &= registrar->parameter(input_, \"input\", \"Input\",\n \"Receiver channel receiving messages from other graph entities\");\n return ToResultCode(result);\n }\n gxf_result_t start() override {\n cudaStream_t streams[10];\n for (int i = 0; i < num_stream_pools_.get(); i++) {\n auto stream = stream_pools_.get()[i].value()->allocateStream();\n streams_.push_back(stream.value());\n streams[i] = stream.value()->stream().value();\n }\n test_smid_with_different_configurations(&streams[0], num_stream_pools_.get());\n return GXF_SUCCESS;\n }\n\n gxf_result_t stop() override {\n for (int i = 0; i < num_stream_pools_.get(); i++) {\n stream_pools_.get()[i].value()->releaseStream(streams_[i]);\n }\n return GXF_SUCCESS;\n }\n\n gxf_result_t tick() override {\n // This test is done in start()\n return GXF_SUCCESS;\n }\n\n private:\n Parameter, kMaxComponents> > stream_pools_;\n Parameter num_stream_pools_;\n Parameter> input_;\n\n std::vector> streams_;\n};\n\n// Performs an async 2D convolution operation on\n// incoming CudaBuffer objects.\nclass Convolve2D: public Codelet {\n public:\n virtual ~Convolve2D() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(kernel_, \"kernel\", \"Kernel\",\n \"2d matrix of float values represented as a vector of vectors\");\n result &= registrar->parameter(output_, \"output\", \"Output\",\n \"Transmitter channel publishing messages to other graph entities\");\n result &= registrar->parameter(input_, \"input\", \"Input\",\n \"Receiver channel receiving messages from other graph entities\");\n result &= registrar->parameter(allocator_, \"allocator\", \"Allocator\",\n \"A cuda allocator component that can serve device memory asynchronously\");\n return ToResultCode(result);\n }\n\n gxf_result_t start() override {\n auto& kernel = kernel_.get();\n size_t kernel_size = kernel.size();\n\n size_t index = 0;\n float kernel_flat_host[kernel_size * kernel_size]; // NOLINT\n for (const auto& k : kernel) {\n GXF_ASSERT_EQ(k.size(), kernel_size);\n for (const auto& value : k) {\n kernel_flat_host[index] = value;\n ++index;\n }\n }\n\n auto maybe_kernel = allocator_->allocate(kernel_size * kernel_size * sizeof(float),\n MemoryStorageType::kDevice);\n if (!maybe_kernel) {\n return maybe_kernel.error();\n }\n\n kernel_flat_ = maybe_kernel.value();\n const cudaError_t error =\n cudaMemcpy(kernel_flat_, kernel_flat_host, kernel_size * kernel_size * sizeof(float),\n cudaMemcpyHostToDevice);\n if (error != cudaSuccess) {\n GXF_LOG_ERROR(\"CUDA Mem copy Error: %s\\n\", cudaGetErrorString(error));\n return GXF_FAILURE;\n }\n return GXF_SUCCESS;\n }\n\n\n gxf_result_t stop() override {\n entity_queue_map_.clear();\n return ToResultCode(allocator_->free(kernel_flat_));\n }\n\n gxf_result_t tick() override {\n return ToResultCode(_tick());\n }\n\n // payload struct to access on the callback used to\n // dereference the underlying message entity\n typedef struct callBackData {\n Entity data;\n Convolve2D* ptr;\n } callBackData;\n\n static void CUDART_CB cudaEntityFreeCallback(void* data_ptr) {\n auto data = reinterpret_cast(data_ptr);\n auto convolve = data->ptr;\n GXF_LOG_VERBOSE(\"Received entity free callback from cuda stream for \"\n \"cuda buffer in message entity E[%05ld]\", data->data.eid());\n // Entities consumed until now cannot be freed just yet in the host callback function.\n // Host callback function gets executed from a cuda driver thread which cannot be used\n // to call another cuda runtime api like cudaFreeAsync. Hence keep track of the\n // entities to be freed the next time this codelet is executed.\n std::unique_lock lock(convolve->mutex_);\n convolve->entity_free_list_.push(data->data.eid());\n }\n\n Expected _tick() {\n // Dequeue any previously consumed message entities\n {\n std::unique_lock lock(mutex_);\n while (!entity_free_list_.empty()) {\n auto element = entity_free_list_.front();\n entity_queue_map_.erase(element);\n entity_free_list_.pop();\n }\n }\n\n auto in_message = GXF_UNWRAP_OR_RETURN(input_->receive());\n GXF_LOG_INFO(\"Message Received: %d\", this->count_);\n this->count_ = this->count_ + 1;\n if (in_message.is_null()) {\n return Unexpected{GXF_CONTRACT_MESSAGE_NOT_AVAILABLE};\n }\n\n auto in_buffer = GXF_UNWRAP_OR_RETURN(in_message.get());\n auto out_message = GXF_UNWRAP_OR_RETURN(Entity::New(context()));\n auto out_buffer = GXF_UNWRAP_OR_RETURN(out_message.add(kDefaultCudaBufferName));\n\n auto stream_pool = in_buffer->streamPool();\n auto stream_handle = in_buffer->transferStreamOwnership();\n auto code = out_buffer->resizeAsync(allocator_, stream_pool, in_buffer->size(), stream_handle);\n\n const int width = 32, height = 32;\n auto cu_stream = GXF_UNWRAP_OR_RETURN(stream_handle->stream());\n\n convolveKernel(reinterpret_cast(in_buffer->pointer()),\n reinterpret_cast(kernel_flat_),\n reinterpret_cast(out_buffer->pointer()),\n width, height, kernel_.get().size(), cu_stream);\n\n cudaError_t err = cudaGetLastError();\n if (err != cudaSuccess) {\n GXF_LOG_ERROR(\"CUDA convolveKernel Error: %s\\n\", cudaGetErrorString(err));\n return Unexpected{GXF_FAILURE};\n }\n\n // store the incoming message entity to prevent the cuda buffer getting released\n // before it is consumed. The in_message entity is only released once the kernel\n // has finished its execution\n auto eid = in_message.eid();\n {\n std::unique_lock lock(mutex_);\n entity_queue_map_.insert({eid, callBackData{std::move(in_message), this}});\n }\n auto it = entity_queue_map_.find(eid);\n\n\n GXF_RETURN_IF_ERROR(in_buffer->registerCallbackOnStream(cudaEntityFreeCallback,\n reinterpret_cast(&it->second)));\n\n auto stream_id = GXF_UNWRAP_OR_RETURN(out_message.add());\n stream_id->stream_cid = stream_handle.cid();\n return output_->publish(out_message);\n }\n\n private:\n Parameter> allocator_;\n Parameter>> kernel_;\n Parameter> output_;\n Parameter> input_;\n byte* kernel_flat_;\n std::unordered_map entity_queue_map_;\n std::queue entity_free_list_;\n std::shared_mutex mutex_;\n int count_ = 1;\n};\n\n// Dequeue a message entity with a cuda buffer and ensures\n// the data is available\nclass CudaBufferRx: public Codelet {\n public:\n virtual ~CudaBufferRx() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(signal_, \"signal\", \"Signal\",\n \"Channel to receive messages from another graph entity\");\n return ToResultCode(result);\n }\n\n gxf_result_t tick() override {\n auto maybe_message = signal_->receive();\n GXF_LOG_INFO(\"Message Received: %d\", this->count);\n this->count = this->count + 1;\n if (!maybe_message || maybe_message.value().is_null()) {\n return GXF_CONTRACT_MESSAGE_NOT_AVAILABLE;\n }\n\n auto message = maybe_message.value();\n auto maybe_cuda_buffer = message.get();\n if (!maybe_cuda_buffer) { return ToResultCode(maybe_cuda_buffer); }\n\n auto cuda_buffer = maybe_cuda_buffer.value();\n auto state = cuda_buffer->state();\n if (state != CudaBuffer::State::DATA_AVAILABLE) {\n GXF_LOG_ERROR(\"CudaBuffer found in an invalid state %d\", static_cast(state));\n return GXF_FAILURE;\n }\n\n return GXF_SUCCESS;\n }\n\n private:\n Parameter> signal_;\n int count = 1;\n};\n\n// Tracks unique SM IDs used during CUDA kernel executions and validates SM count\nclass CudaSMCount : public Codelet {\n public:\n gxf_result_t initialize() override {\n unique_smids_.clear();\n return GXF_SUCCESS;\n }\n\n gxf_result_t tick() override {\n std::lock_guard lock(smids_mutex_);\n\n // Default kernel configuration\n int num_blocks = 64;\n int threads_per_block = 1024;\n\n int32_t result = 0;\n\n // Check if we have a stream pool\n const auto maybe_stream_pool = stream_pool_.try_get();\n if (maybe_stream_pool) {\n // Allocate a stream from the pool\n auto stream = maybe_stream_pool.value()->allocateStream();\n if (!stream) {\n GXF_LOG_ERROR(\"Failed to allocate stream from pool\");\n return GXF_FAILURE;\n }\n\n // Launch kernel with stream\n result = collect_smid_from_kernel(num_blocks, threads_per_block,\n stream.value()->stream().value(), unique_smids_);\n\n // Release the stream back to the pool\n auto release_result = maybe_stream_pool.value()->releaseStream(stream.value());\n if (!release_result) {\n GXF_LOG_ERROR(\"Failed to release stream back to pool\");\n return GXF_FAILURE;\n }\n } else {\n // Launch kernel without stream\n result = collect_smid_from_kernel(num_blocks, threads_per_block, nullptr, unique_smids_);\n }\n\n if (result != 0) {\n GXF_LOG_ERROR(\"Failed to collect SM IDs from kernel\");\n return GXF_FAILURE;\n }\n\n return GXF_SUCCESS;\n }\n\n gxf_result_t deinitialize() override {\n std::lock_guard lock(smids_mutex_);\n if (unique_smids_.size() > max_smid_count_.get()) {\n GXF_LOG_ERROR(\"SM count check failed: used %zu SMs, expected no more than %zu\",\n unique_smids_.size(), max_smid_count_.get());\n return GXF_FAILURE;\n }\n return GXF_SUCCESS;\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(\n max_smid_count_, \"max_smid_count\", \"Maximum number of SMs\",\n \"Maximum number of unique SMs expected to be used by CUDA kernels\", 1UL);\n result &= registrar->parameter(stream_pool_, \"stream_pool\", \"Cuda Stream Pool\",\n \"Optional CUDA stream pool for kernel execution\",\n Registrar::NoDefaultParameter(), GXF_PARAMETER_FLAGS_OPTIONAL);\n return ToResultCode(result);\n }\n\n private:\n Parameter max_smid_count_;\n Parameter> stream_pool_;\n std::set unique_smids_;\n mutable std::mutex smids_mutex_;\n};\n\n} // namespace cuda\n\n} // namespace test\n\n} // namespace gxf\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_CUDA_TESTS_TEST_CUDA_HELPER_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/logger/gxf_logger.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef COMMON_LOGGER_GXF_LOGGER_HPP\n#define COMMON_LOGGER_GXF_LOGGER_HPP\n\n#include \n#include \n\n#include \"gxf/logger/logger.hpp\"\n\nnamespace nvidia {\n\n// Environment variable for log level override\nconstexpr const char* kGxfLogEnvName = \"GXF_LOG_LEVEL\";\n\n// Indicates the level of severity for a log message\nenum class Severity {\n // A utility case which can be used for 'SetSeverity' to disable all severity levels.\n NONE = -2,\n // A utility case which can be used for 'Redirect' and 'SetSeverity'\n ALL = -1,\n // The five different log severities in use from most severe to least severe.\n PANIC = 0, // Need to start at 0\n ERROR,\n WARNING,\n INFO,\n DEBUG,\n VERBOSE,\n // A utility case representing the number of log levels used internally.\n COUNT\n};\n\n// The output severity which might limit certain levels of severity\nstruct SeverityContainer {\n Severity r = Severity::INFO;\n\n // Sets the default severity from the environment variable if it is set.\n SeverityContainer();\n};\n\n/// Namespace for the NVIDIA logger functionality.\nnamespace logger {\n\n/// A logger that utilizes the GXF logging system.\n///\n/// The GXF logger supports six log levels:\n/// PANIC(0), ERROR(1), WARNING(2), INFO(3), DEBUG(4), and VERBOSE(5).\n///\n/// If no logger or log function is provided, a default logger implementation (DefaultGxfLogger) is\n/// used. The default logger leverages the existing functionality of the GXF logging system, which\n/// employs a global/singleton SeverityContainer to control the logging level, and a global\n/// `nvidia::LoggingFunction` to log messages.\n/// The initial logging level is determined by the environment variable `GXF_LOG_LEVEL` if it is\n/// set. Otherwise, the default logging level is INFO(3).\nclass GxfLogger : public Logger {\n public:\n /// Constructs a logger with the provided logger or log function.\n ///\n /// If neither a logger nor a log function is provided, a default GXF logger will be instantiated.\n ///\n /// @param logger The logger to use (default: nullptr).\n /// @param func The log function to use (default: nullptr).\n explicit GxfLogger(const std::shared_ptr& logger = nullptr,\n const LogFunction& func = nullptr);\n};\n\n/// A logger that facilitates access to the global GXF logger.\n///\n/// The singleton GXF logger can be accessed via the instance() method.\n/// This class also provides a method to set the log severity from an environment variable.\n/// The log severity can be retrieved from the environment variable using GetSeverityFromEnv().\nclass GlobalGxfLogger {\n public:\n /// Retrieve the global/singleton GXF logger instance.\n static GxfLogger& instance();\n\n /// Set the log severity based on the value of an environment variable.\n ///\n /// If the environment variable is not set or invalid, the severity remains unchanged.\n /// @param env_name The name of the environment variable to use.\n /// @return true if the environment variable is accessible and the severity was updated from it.\n static bool SetSeverityFromEnv(const char* env_name);\n\n /// Return the log severity based on the value of an environment variable.\n ///\n /// If the environment variable is not set or invalid, returns Severity::COUNT.\n /// If 'error_code' is not null, it will be set to 1 if the environment variable is set but\n /// invalid, or to 0 otherwise.\n ///\n /// @param env_name The name of the environment variable to use.\n /// @param error_code The error code to set if the environment variable is invalid.\n /// @return The log severity from the environment variable.\n static Severity GetSeverityFromEnv(const char* env_name, int* error_code);\n};\n\n} // namespace logger\n\n} // namespace nvidia\n\n#endif /* COMMON_LOGGER_GXF_LOGGER_HPP */\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/logger/logger.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef COMMON_LOGGER_LOGGER_HPP\n#define COMMON_LOGGER_LOGGER_HPP\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace nvidia {\n\n/// Namespace for the NVIDIA logger functionality.\nnamespace logger {\n\nusing LogFunction = std::function;\n\n/// Interface for custom logger implementations.\n///\n/// ILogger provides an interface for implementing custom logging mechanisms.\n/// This interface allows the integration of various logging systems with the Logger class.\n/// Users can define their own logging behavior by implementing these methods.\nclass ILogger {\n public:\n /// Destructor for ILogger.\n virtual ~ILogger() = default;\n\n /// Log a message.\n ///\n /// This method logs a message based on the provided details such as file name, line number,\n /// function/module name, log level, message, and an optional argument.\n ///\n /// @param file The name of the source file where the log request originated.\n /// @param line The line number in the source file.\n /// @param name The name of the function/module making the log request.\n /// @param level The log level.\n /// @param message The log message.\n /// @param arg An optional argument for additional log information (default: nullptr).\n virtual void log(const char* file, int line, const char* name, int level, const char* message,\n void* arg = nullptr) = 0;\n\n /// Set the log message pattern.\n ///\n /// Set the pattern used for formatting log messages.\n ///\n /// @param pattern The pattern string for formatting log messages.\n virtual void pattern(const char* pattern) = 0;\n\n /// Get the current log message pattern.\n ///\n /// Retrieve the currently set pattern used for formatting log messages.\n ///\n /// @return The currently set pattern string.\n virtual const char* pattern() const = 0;\n\n /// Set the log level.\n ///\n /// Set the log level, determining the priority of messages that should be logged.\n ///\n /// @param level The log level.\n virtual void level(int level) = 0;\n\n /// Get the current log level.\n ///\n /// Retrieve the currently set log level.\n ///\n /// @return The currently set log level.\n virtual int level() const = 0;\n\n /// Redirect log output.\n ///\n /// Redirect log output to the specified file or other output for the given log level.\n ///\n /// @param level The log level for which output redirection is applied.\n /// @param output A pointer to the file or other output to redirect log output.\n virtual void redirect(int level, void* output) = 0;\n\n /// Get the current redirection for a specified log level.\n ///\n /// Retrieve the file/output pointer to which log output is currently being redirected for the\n /// specified log level. If no redirection is set for the given level, returns nullptr.\n ///\n /// @param level The log level for which the redirection is queried.\n /// @return A pointer to the file/output where log output is redirected, or nullptr if no\n /// redirection is set.\n virtual void* redirect(int level) const = 0;\n};\n\n/// Logger class for logging messages.\n///\n/// The Logger class provides a flexible and customizable logging system. It supports a variety of\n/// output targets, such as strings, standard error streams, files, or even network endpoints, and\n/// allows for logging at different levels of severity. This versatility makes it suitable for a\n/// wide range of applications and use cases.\n///\n/// A key feature of the Logger is its ability to be specialized. Users can create a custom logger\n/// specialization (for example, targeting a string, standard error, a file, or a network endpoint)\n/// according to their specific needs. Once created, this specialized logger can be configured and\n/// used consistently across various components of an application.\n///\n/// In addition to its flexibility in terms of output and configuration, the Logger class supports\n/// both singleton and regular class usage patterns. This provides further versatility in how\n/// logging functionality can be integrated into an application.\n///\n/// The following examples illustrate how to use the Logger in both singleton and regular class\n/// contexts.\n///\n/// ```cpp\n/// class SingletonLogger : public Logger {\n/// public:\n/// static SingletonLogger& instance() {\n/// static SingletonLogger instance;\n/// return instance;\n/// }\n///\n/// private:\n/// SingletonLogger() {\n/// // Set default logger\n/// logger_ = std::make_shared();\n/// func_ = nullptr;\n///\n/// // Set level\n/// level(logger_->level());\n///\n/// // Set pattern\n/// pattern(logger_->pattern());\n///\n/// // Set sinks\n/// for (int severity = kNumSeverity - 1; severity >= 0; --severity) {\n/// redirect(severity, s_sinks[severity]);\n/// }\n/// }\n/// };\n/// // ...\n/// SingletonLogger::instance().log(__FILE__, __LINE__, __FUNCTION__, 0, \"Hello World!\");\n/// ```\n///\n/// The following example shows how to use Logger as a regular class:\n///\n/// ```cpp\n/// class TestLogger : public Logger {\n/// public:\n/// static std::shared_ptr create() { return std::make_shared(); }\n/// };\n/// // ...\n/// std::shared_ptr logger = TestLogger::create();\n/// logger->log(__FILE__, __LINE__, __FUNCTION__, 0, \"Hello World!\");\n/// ```\nclass Logger {\n public:\n /// Construct a logger instance.\n Logger() = default;\n\n /// Construct a logger instance with the custom logger.\n ///\n /// @param logger A shared pointer to the custom logger.\n explicit Logger(const std::shared_ptr& logger);\n\n /// Construct a logger instance with the custom log function.\n ///\n /// @param func The custom log function.\n explicit Logger(const LogFunction& func);\n\n /// Construct a logger instance with the custom logger or log function.\n ///\n /// @param logger A shared pointer to the custom logger.\n /// @param func The custom log function.\n Logger(const std::shared_ptr logger, const LogFunction& func);\n\n /// Log a message.\n ///\n /// Log a message using either a custom logger set via logger() or func().\n /// The custom logger set via func() has priority over the one set via logger(). If neither is\n /// set, no logging occurs.\n ///\n /// @param file The name of the source file where the log request originated.\n /// @param line The line number in the source file.\n /// @param name The name of the function/module making the log request.\n /// @param level The log level.\n /// @param message The log message.\n void log(const char* file, int line, const char* name, int level, const char* message);\n\n /// Set a custom logger.\n ///\n /// Register a custom logger to be used for logging messages. The custom logger must implement\n /// the ILogger interface.\n ///\n /// @param custom_logger A shared pointer to the custom logger.\n void logger(std::shared_ptr custom_logger);\n\n /// Get the current custom logger.\n ///\n /// Retrieve the currently set custom logger.\n ///\n /// @return A shared pointer to the currently set custom logger.\n std::shared_ptr logger() const;\n\n /// Set a custom log function.\n ///\n /// Register a custom log function and an argument to be used for logging messages. This function\n /// has higher priority over the custom logger set via logger().\n /// If func_arg is not nullptr, func_arg will be passed to log_func as an argument ('arg'\n /// parameter).\n ///\n /// @param log_func The custom log function.\n /// @param func_arg An opaque pointer to auxiliary data needed by log_func.\n void func(LogFunction log_func, void* func_arg = nullptr);\n\n /// Get the current custom log function.\n ///\n /// Retrieve the currently set custom log function.\n ///\n /// @return The currently set custom log function.\n LogFunction func() const;\n\n /// Get the current custom log function argument.\n ///\n /// Retrieve the currently set custom log function argument.\n ///\n /// @return The currently set custom log function argument.\n void* arg() const;\n\n /// Set the log message pattern.\n ///\n /// Set the pattern used for formatting log messages.\n ///\n /// @param pattern The pattern string for formatting log messages.\n void pattern(const char* pattern);\n\n /// Get the current log message pattern.\n ///\n /// Retrieve the currently set pattern used for formatting log messages.\n ///\n /// @return The currently set pattern string.\n const char* pattern() const;\n\n /// Set the log level.\n ///\n /// Set the log level, determining the priority of messages that should be logged.\n ///\n /// @param level The log level.\n void level(int level);\n\n /// Get the current log level.\n ///\n /// Retrieve the currently set log level.\n ///\n /// @return The currently set log level.\n int level() const;\n\n /// Redirect log output.\n ///\n /// Redirect log output to the specified file or other output for the given log level.\n ///\n /// @param level The log level for which output redirection is applied.\n /// @param output A pointer to the file or other output to redirect log output.\n void redirect(int level, void* output);\n\n /// Get the current redirection for a specified log level.\n ///\n /// Retrieve the file/output pointer to which log output is currently being redirected for the\n /// specified log level. If no redirection is set for the given level, returns nullptr.\n ///\n /// @param level The log level for which the redirection is queried.\n /// @return A pointer to the file/output where log output is redirected, or nullptr if no\n /// redirection is set.\n void* redirect(int level) const;\n\n protected:\n std::shared_ptr logger_; ///< shared pointer to the logger\n LogFunction func_; ///< log function\n void* func_arg_ = nullptr; ///< log function argument\n\n std::string pattern_; ///< log pattern\n int level_ = 0; ///< log level\n std::vector sinks_; ///< log sinks\n};\n\n} // namespace logger\n\n} // namespace nvidia\n\n#endif /* COMMON_LOGGER_LOGGER_HPP */\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/multimedia/audio.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_MULTIMEDIA_AUDIO_HPP_\n#define NVIDIA_GXF_MULTIMEDIA_AUDIO_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/memory_buffer.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Supported raw audio media types\nenum class AudioFormat {\n GXF_AUDIO_FORMAT_CUSTOM = 0,\n GXF_AUDIO_FORMAT_S16LE, // 16-bit signed PCM audio\n GXF_AUDIO_FORMAT_F32LE, // 32-bit floating-point audio\n};\n\n// Supported channel layouts\nenum class AudioLayout {\n GXF_AUDIO_LAYOUT_CUSTOM = 0,\n GXF_AUDIO_LAYOUT_INTERLEAVED, // Data from all the channels to be interleaved LRLRLR\n GXF_AUDIO_LAYOUT_NON_INTERLEAVED, // Data from all the channels not to be interleaved LLLRRR\n};\n\ntemplate \nstruct AudioTypeTraits;\n\n#define GXF_AUDIO_TYPE_TRAITS(ENUM, WIDTH) \\\n template <> \\\n struct AudioTypeTraits { \\\n static constexpr const char* name = #ENUM; \\\n static constexpr const AudioFormat value = AudioFormat::ENUM; \\\n static constexpr const int8_t width = WIDTH; \\\n };\n\nGXF_AUDIO_TYPE_TRAITS(GXF_AUDIO_FORMAT_CUSTOM, 0);\nGXF_AUDIO_TYPE_TRAITS(GXF_AUDIO_FORMAT_S16LE, 16);\nGXF_AUDIO_TYPE_TRAITS(GXF_AUDIO_FORMAT_F32LE, 32);\n\n// Descriptor for an AudioBuffer\nstruct AudioBufferInfo {\n // Number of channels in an audio frame\n uint32_t channels;\n // Number of samples in an audio frame\n uint32_t samples;\n // sampling rate in Hz\n uint32_t sampling_rate;\n // Number of bytes required per sample\n uint32_t bytes_per_sample;\n // AudioFormat of an audio frame\n AudioFormat audio_format;\n // AudioLayout of an audio frame\n AudioLayout audio_layout;\n};\n\n// A media data type which stores information corresponding to an audio frame\n// resize(...) function is used to allocate memory for the audio frame based on\n// the audio frame info\nclass AudioBuffer {\n public:\n AudioBuffer() = default;\n\n ~AudioBuffer() { memory_buffer_.freeBuffer(); }\n\n AudioBuffer(const AudioBuffer&) = delete;\n\n AudioBuffer(AudioBuffer&& other) { *this = std::move(other); }\n\n AudioBuffer& operator=(const AudioBuffer&) = delete;\n\n AudioBuffer& operator=(AudioBuffer&& other) {\n buffer_info_ = other.buffer_info_;\n memory_buffer_ = std::move(other.memory_buffer_);\n\n return *this;\n }\n\n template \n Expected resize(uint32_t channels, uint32_t samples, uint32_t sampling_rate,\n AudioLayout layout, MemoryStorageType storage_type,\n Handle allocator) {\n AudioTypeTraits audio_type;\n uint32_t bytes_per_sample = std::ceil(audio_type.width / 8);\n AudioBufferInfo buffer_info{channels, samples, sampling_rate,\n bytes_per_sample, audio_type.value, layout};\n return resizeCustom(buffer_info, storage_type, allocator);\n }\n\n // Type of the callback function to release memory passed to the AudioFrame using the\n // wrapMemory method\n using release_function_t = MemoryBuffer::release_function_t;\n\n // Wrap existing memory inside the AudioBuffer. A callback function of type release_function_t\n // may be passed that will be called when the AudioBuffer wants to release the memory.\n Expected wrapMemory(AudioBufferInfo buffer_info, uint64_t size,\n MemoryStorageType storage_type, void* pointer,\n release_function_t release_func);\n\n // AudioBufferInfo of the AudioBuffer\n AudioBufferInfo audio_buffer_info() const { return buffer_info_; }\n\n // The type of memory where the frame data is stored.\n MemoryStorageType storage_type() const { return memory_buffer_.storage_type(); }\n\n // Size of the audio frame in bytes\n uint64_t size() const { return memory_buffer_.size(); }\n\n // Raw pointer to the first byte of the audio frame\n byte* pointer() const { return memory_buffer_.pointer(); }\n\n // Resizes the audio frame and allocates the corresponding memory with the allocator provided\n // Any data previously stored in the frame would be freed\n Expected resizeCustom(AudioBufferInfo buffer_info, MemoryStorageType storage_type,\n Handle allocator);\n\n private:\n AudioBufferInfo buffer_info_;\n MemoryBuffer memory_buffer_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_MULTIMEDIA_AUDIO_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/multimedia/camera.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_MULTIMEDIA_CAMERA_HPP_\n#define NVIDIA_GXF_MULTIMEDIA_CAMERA_HPP_\n\n#include \n#include \n#include \"gxf/multimedia/video.hpp\"\n#include \"gxf/std/timestamp.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\ntemplate \nstruct Vector2 {\n T x; /**< point x coordinate. */\n T y; /**< point y coordinate. */\n};\n\nusing Vector2u = Vector2;\nusing Vector2f = Vector2;\nusing Vector2d = Vector2;\n\nenum class DistortionType {\n /**\n * No distortion\n */\n Perspective,\n /**\n * Brown model with 3 radial and 2 tangential distortion coefficients.\n */\n Brown,\n /**\n * Polynomial model with 6 radial and 2 tangential distortion coefficients.\n */\n Polynomial,\n /**\n * Fisheye model with 4 radial distortion coefficients.\n * Specifies the equidistant fisheye mapping.\n * Mapping is defined by:\n * \\f[r = f\\theta\\f]\n * where:\n * - \\f$\\theta\\f$ is the angle from the optical axis.\n * - \\f$f\\f$ is the focal length.\n * - \\f$r\\f$ is the distance of a pixel from the image center.\n */\n FisheyeEquidistant,\n /**\n * Fisheye model with 4 radial distortion coefficients.\n * Specifies the equisolid fisheye mapping.\n * Mapping is defined by:\n * \\f[r = 2f\\sin\\left(\\frac{\\theta}{2}\\right)\\f]\n * where:\n * - \\f$\\theta\\f$ is the angle from the optical axis.\n * - \\f$f\\f$ is the focal length.\n * - \\f$r\\f$ is the distance of a pixel from the image center.\n */\n FisheyeEquisolid,\n /**\n * Fisheye model with 4 radial distortion coefficients.\n * Specifies the orthographic fisheye mapping.\n * Mapping is defined by:\n * \\f[r = f\\sin(\\theta)\\f]\n * where:\n * - \\f$\\theta\\f$ is the angle from the optical axis.\n * - \\f$f\\f$ is the focal length.\n * - \\f$r\\f$ is the distance of a pixel from the image center.\n */\n FisheyeOrthoGraphic,\n /**\n * Fisheye model with 4 radial distortion coefficients.\n * Specifies the stereographic fisheye mapping.\n * Mapping is defined by:\n * \\f[r = 2f\\tan\\left(\\frac{\\theta}{2}\\right)\\f]\n * where:\n * - \\f$\\theta\\f$ is the angle from the optical axis.\n * - \\f$f\\f$ is the focal length.\n * - \\f$r\\f$ is the distance of a pixel from the image center.\n */\n FisheyeStereographic,\n};\n\n/**\n * Camera intrinsics model.\n * Intrinsic camera matrix is defined as follow:\n * [fx s cx]\n * K = [ 0 fy cy]\n * [ 0 0 1]\n * where:\n * - fx, fy represent focal length.\n * - cx, cy represent principle point.\n * - s represents the skew value.\n */\ntemplate \nstruct CameraModelBase {\n // The maximum number of distortion coefficients.\n static constexpr int kMaxDistortionCoefficients = 8;\n // The dimensions of the camera image plane in pixels in the order x, y.\n Vector2u dimensions;\n // Focal length of the projection (in pixels) in the order x, y.\n Vector2 focal_length;\n // Optical center of the projection (in pixels) in the order x, y.\n Vector2 principal_point;\n // The skew coefficient between the x and the y axis (usually 0).\n T skew_value;\n // Distortion type of the camera.\n DistortionType distortion_type;\n // Distortion coefficients of the camera.\n std::array distortion_coefficients;\n};\n\nusing CameraModel = CameraModelBase;\n\n/**\n * Camera extrinsics model.\n * Extrinsic camera matrix is defined as follow:\n * T = [R | t]\n * where:\n * - R is the rotation matrix.\n * - t is the translation vector.\n */\ntemplate \nstruct Pose3DBase {\n // The 3x3 rotation matrix.\n std::array rotation;\n // The translation vector.\n std::array translation;\n};\n\nusing Pose3D = Pose3DBase;\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_MULTIMEDIA_CAMERA_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/multimedia/video.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_MULTIMEDIA_VIDEO_HPP_\n#define NVIDIA_GXF_MULTIMEDIA_VIDEO_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/memory_buffer.hpp\"\n#include \"gxf/std/tensor.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n#ifdef __aarch64__\nstatic constexpr const uint16_t kGxfAlignValue = 256;\n#else\nstatic constexpr const uint16_t kGxfAlignValue = 256;\n#endif\n\n// Align frame stride to kGxfAlignValue\nstatic constexpr uint32_t StrideAlign(uint32_t stride) {\n return (stride % kGxfAlignValue == 0) ? stride : ((stride / kGxfAlignValue + 1) * kGxfAlignValue);\n}\n\n// Compute strides for video buffer\n//\n// If stride is non zero, use it as it is\n// If stride is not set and align is enabled (default), use align(w * bytes)\n// If stride is not set and align is disabled, use (w * bytes)\nstatic constexpr uint32_t ComputeStrides(bool stride_align, uint32_t width,\n uint32_t bytes_per_pixel,\n uint32_t stride) {\n if (stride != 0) {\n // Use existing stride without alignment\n return stride;\n } else if (stride_align) {\n // unset stride, align based on width\n return StrideAlign(width * bytes_per_pixel);\n } else {\n // return unaligned buffer\n return width * bytes_per_pixel;\n }\n}\n\n// Round up to the closest even number\nstatic constexpr uint32_t AlignToEvenDimension(uint32_t value) {\n return value + (value & 1);\n}\n\n// Supported raw video media types\nenum class VideoFormat : std::int64_t {\n GXF_VIDEO_FORMAT_CUSTOM = 0,\n GXF_VIDEO_FORMAT_YUV420, // BT.601 multi planar 4:2:0 YUV\n GXF_VIDEO_FORMAT_YUV420_ER, // BT.601 multi planar 4:2:0 YUV ER\n GXF_VIDEO_FORMAT_YUV420_709, // BT.709 multi planar 4:2:0 YUV\n GXF_VIDEO_FORMAT_YUV420_709_ER, // BT.709 multi planar 4:2:0 YUV\n GXF_VIDEO_FORMAT_NV12, // BT.601 multi planar 4:2:0 YUV with interleaved UV\n GXF_VIDEO_FORMAT_NV12_ER, // BT.601 multi planar 4:2:0 YUV ER with interleaved UV\n GXF_VIDEO_FORMAT_NV12_709, // BT.709 multi planar 4:2:0 YUV with interleaved UV\n GXF_VIDEO_FORMAT_NV12_709_ER, // BT.709 multi planar 4:2:0 YUV ER with interleaved UV\n GXF_VIDEO_FORMAT_RGBA, // RGBA-8-8-8-8 single plane\n GXF_VIDEO_FORMAT_BGRA, // BGRA-8-8-8-8 single plane\n GXF_VIDEO_FORMAT_ARGB, // ARGB-8-8-8-8 single plane\n GXF_VIDEO_FORMAT_ABGR, // ABGR-8-8-8-8 single plane\n GXF_VIDEO_FORMAT_RGBX, // RGBX-8-8-8-8 single plane\n GXF_VIDEO_FORMAT_BGRX, // BGRX-8-8-8-8 single plane\n GXF_VIDEO_FORMAT_XRGB, // XRGB-8-8-8-8 single plane\n GXF_VIDEO_FORMAT_XBGR, // XBGR-8-8-8-8 single plane\n GXF_VIDEO_FORMAT_RGB, // RGB-8-8-8 single plane\n GXF_VIDEO_FORMAT_BGR, // BGR-8-8-8 single plane\n GXF_VIDEO_FORMAT_R8_G8_B8, // RGB - unsigned 8 bit multiplanar\n GXF_VIDEO_FORMAT_B8_G8_R8, // BGR - unsigned 8 bit multiplanar\n GXF_VIDEO_FORMAT_GRAY, // 8 bit GRAY scale single plane\n GXF_VIDEO_FORMAT_GRAY16, // 16 bit GRAY scale single plane\n GXF_VIDEO_FORMAT_GRAY32, // 32 bit GRAY scale single plane\n GXF_VIDEO_FORMAT_GRAY32F, // float 32 bit GRAY scale single plane\n GXF_VIDEO_FORMAT_RGB16, // RGB-16-16-16 single plane\n GXF_VIDEO_FORMAT_BGR16, // BGR-16-16-16 single plane\n GXF_VIDEO_FORMAT_RGB32, // RGB-32-32-32 single plane\n GXF_VIDEO_FORMAT_BGR32, // BGR-32-32-32 single plane\n GXF_VIDEO_FORMAT_R16_G16_B16, // RGB - signed 16 bit multiplanar\n GXF_VIDEO_FORMAT_B16_G16_R16, // BGR - signed 16 bit multiplanar\n GXF_VIDEO_FORMAT_R32_G32_B32, // RGB - signed 32 bit multiplanar\n GXF_VIDEO_FORMAT_B32_G32_R32, // BGR - signed 32 bit multiplanar\n GXF_VIDEO_FORMAT_NV24, // multi planar 4:4:4 YUV with interleaved UV\n GXF_VIDEO_FORMAT_NV24_ER, // multi planar 4:4:4 YUV ER with interleaved UV\n GXF_VIDEO_FORMAT_R8_G8_B8_D8, // RGBD unsigned 8 bit multiplanar\n GXF_VIDEO_FORMAT_R16_G16_B16_D16, // RGBD unsigned 16 bit multiplanar\n GXF_VIDEO_FORMAT_R32_G32_B32_D32, // RGBD unsigned 32 bit multiplanar\n GXF_VIDEO_FORMAT_RGBD8, // RGBD 8 bit unsigned single plane\n GXF_VIDEO_FORMAT_RGBD16, // RGBD 16 bit unsigned single plane\n GXF_VIDEO_FORMAT_RGBD32, // RGBD 32 bit unsigned single plane\n GXF_VIDEO_FORMAT_D32F, // Depth 32 bit float single plane\n GXF_VIDEO_FORMAT_D64F, // Depth 64 bit float single plane\n GXF_VIDEO_FORMAT_RAW16_RGGB, // RGGB-16-16-16-16 single plane\n GXF_VIDEO_FORMAT_RAW16_BGGR, // BGGR-16-16-16-16 single plane\n GXF_VIDEO_FORMAT_RAW16_GRBG, // GRBG-16-16-16-16 single plane\n GXF_VIDEO_FORMAT_RAW16_GBRG, // GBRG-16-16-16-16 single plane\n};\n\n// Supported surface memory types\nenum class SurfaceLayout : std::int32_t {\n GXF_SURFACE_LAYOUT_INVALID = 0,\n GXF_SURFACE_LAYOUT_PITCH_LINEAR, // pitch linear surface memory\n GXF_SURFACE_LAYOUT_BLOCK_LINEAR, // block linear surface memory\n};\n\ntemplate \nstruct VideoTypeTraits;\n\n#define GXF_VIDEO_TYPE_TRAITS(ENUM) \\\n template <> \\\n struct VideoTypeTraits { \\\n static constexpr const char* name = #ENUM; \\\n static constexpr const VideoFormat value = VideoFormat::ENUM; \\\n };\n\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_CUSTOM);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_YUV420);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_YUV420_ER);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_YUV420_709);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_YUV420_709_ER);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_NV12);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_NV12_ER);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_NV12_709);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_NV12_709_ER);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RGBA);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_BGRA);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_ARGB);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_ABGR);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RGBX);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_BGRX);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_XRGB);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_XBGR);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RGB);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_BGR);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_R8_G8_B8);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_B8_G8_R8);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_GRAY);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_GRAY16);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_GRAY32);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_GRAY32F);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RGB16);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_BGR16);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RGB32);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_BGR32);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_R16_G16_B16);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_B16_G16_R16);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_R32_G32_B32);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_B32_G32_R32);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_NV24);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_NV24_ER);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_R8_G8_B8_D8);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_R16_G16_B16_D16);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_R32_G32_B32_D32);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RGBD8);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RGBD16);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RGBD32);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_D32F);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_D64F);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RAW16_RGGB);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RAW16_BGGR);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RAW16_GRBG);\nGXF_VIDEO_TYPE_TRAITS(GXF_VIDEO_FORMAT_RAW16_GBRG);\n\n\n// Struct to hold the information regarding a single color plane\nstruct ColorPlane {\n std::string color_space;\n uint8_t bytes_per_pixel = 0;\n uint32_t stride = 0;\n uint32_t offset = 0;\n uint32_t width = 0;\n uint32_t height = 0;\n uint64_t size = 0;\n\n ColorPlane() {}\n ColorPlane(const char* c_space, uint8_t c_depth, uint32_t c_stride = 0)\n : color_space(c_space), bytes_per_pixel(c_depth), stride(c_stride) {}\n};\n\n// Template to compute the memory size of an image\n// for different color formats\ntemplate \nstruct VideoFormatSize {\n uint64_t size(uint32_t width, uint32_t height,\n bool stride_align = true) { return 0; }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) { return {}; }\n};\n\n// Specifies YUV420 multi-planar variants\ntemplate \nstruct VideoFormatSize> {\n std::array default_yuv{ColorPlane(\"Y\", 1), ColorPlane(\"U\", 1), ColorPlane(\"V\", 1)};\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_planes,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n color_planes[0].width = widthEven;\n color_planes[1].width = widthEven / 2;\n color_planes[2].width = widthEven / 2;\n color_planes[0].height = heightEven;\n color_planes[1].height = heightEven / 2;\n color_planes[2].height = heightEven / 2;\n\n uint64_t size = 0;\n for (size_t i = 0; i < color_planes.size(); ++i) {\n if (i == 0) {\n color_planes[i].stride = ComputeStrides(stride_align, color_planes[i].width,\n color_planes[i].bytes_per_pixel, color_planes[i].stride);\n } else if (color_planes[i].stride == 0) {\n // YUV formats require UV planes stride to be half of Y plane\n color_planes[i].stride = color_planes[0].stride / 2;\n }\n color_planes[i].size = color_planes[i].stride * color_planes[i].height;\n color_planes[i].offset = size;\n size += color_planes[i].size;\n }\n return size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto yuv = default_yuv;\n fillColorPlanes(width, height, yuv, stride_align);\n std::vector result(yuv.begin(), yuv.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n return fillColorPlanes(width, height, default_yuv, stride_align);\n }\n};\n\n// Specifies YUV444 multi-planar variants\ntemplate \nstruct VideoFormatSize> {\n std::array default_yuv{ColorPlane(\"Y\", 1), ColorPlane(\"UV\", 2)};\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_planes,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n\n uint64_t size = 0;\n for (size_t i = 0; i < color_planes.size(); ++i) {\n color_planes[i].width = widthEven;\n color_planes[i].height = heightEven;\n color_planes[i].stride = ComputeStrides(stride_align, color_planes[i].width,\n color_planes[i].bytes_per_pixel, color_planes[i].stride);\n color_planes[i].size = color_planes[i].stride * color_planes[i].height;\n color_planes[i].offset = size;\n size += color_planes[i].size;\n }\n return size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto yuv = default_yuv;\n fillColorPlanes(width, height, yuv, stride_align);\n std::vector result(yuv.begin(), yuv.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n return fillColorPlanes(width, height, default_yuv, stride_align);\n }\n};\n\n// Specifies NV12 Y/CbCr 4:2:0 multi-planar variants\ntemplate \nstruct VideoFormatSize> {\n std::array default_yuv{ColorPlane(\"Y\", 1), ColorPlane(\"UV\", 2)};\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_planes,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n color_planes[0].width = widthEven;\n color_planes[1].width = widthEven / 2;\n color_planes[0].height = heightEven;\n color_planes[1].height = heightEven / 2;\n\n uint64_t size = 0;\n for (size_t i = 0; i < color_planes.size(); ++i) {\n color_planes[i].stride = ComputeStrides(stride_align, color_planes[i].width,\n color_planes[i].bytes_per_pixel, color_planes[i].stride);\n color_planes[i].size = color_planes[i].stride * color_planes[i].height;\n color_planes[i].offset = size;\n size += color_planes[i].size;\n }\n return size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto yuv = default_yuv;\n fillColorPlanes(width, height, yuv, stride_align);\n std::vector result(yuv.begin(), yuv.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n return fillColorPlanes(width, height, default_yuv, stride_align);\n }\n};\n\n// Specifies 8-8-8-8 single plane RGBX/XRGB variants\ntemplate \nstruct VideoFormatSize<\n T, std::enable_if_t<\n T == VideoFormat::GXF_VIDEO_FORMAT_RGBA || T == VideoFormat::GXF_VIDEO_FORMAT_BGRA ||\n T == VideoFormat::GXF_VIDEO_FORMAT_ARGB || T == VideoFormat::GXF_VIDEO_FORMAT_ABGR ||\n T == VideoFormat::GXF_VIDEO_FORMAT_RGBX || T == VideoFormat::GXF_VIDEO_FORMAT_BGRX ||\n T == VideoFormat::GXF_VIDEO_FORMAT_XRGB || T == VideoFormat::GXF_VIDEO_FORMAT_XBGR>> {\n std::array defaultRGBA() {\n if (T == VideoFormat::GXF_VIDEO_FORMAT_RGBA) {\n return {ColorPlane(\"RGBA\", 4)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_BGRA) {\n return {ColorPlane(\"BGRA\", 4)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_ARGB) {\n return {ColorPlane(\"ARGB\", 4)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_ABGR) {\n return {ColorPlane(\"ABGR\", 4)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_RGBX) {\n return {ColorPlane(\"RGBX\", 4)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_BGRX) {\n return {ColorPlane(\"BGRX\", 4)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_XRGB) {\n return {ColorPlane(\"XRGB\", 4)};\n } else { // T == VideoFormat::GXF_VIDEO_FORMAT_XBGR\n return {ColorPlane(\"XBGR\", 4)};\n }\n }\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_plane,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n color_plane[0].width = widthEven;\n color_plane[0].height = heightEven;\n color_plane[0].stride = ComputeStrides(stride_align, color_plane[0].width,\n color_plane[0].bytes_per_pixel, color_plane[0].stride);\n color_plane[0].size = color_plane[0].stride * color_plane[0].height;\n color_plane[0].offset = 0;\n return color_plane[0].size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto rgba = defaultRGBA();\n fillColorPlanes(width, height, rgba, stride_align);\n std::vector result(rgba.begin(), rgba.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n auto rgba = defaultRGBA();\n return fillColorPlanes(width, height, rgba, stride_align);\n }\n};\n\n// Specifies x-x-x(8/16/32) bit single plane RGB/BGR variants\ntemplate \nstruct VideoFormatSize<\n T, std::enable_if_t<\n T == VideoFormat::GXF_VIDEO_FORMAT_RGB || T == VideoFormat::GXF_VIDEO_FORMAT_BGR ||\n T == VideoFormat::GXF_VIDEO_FORMAT_RGB16 || T == VideoFormat::GXF_VIDEO_FORMAT_BGR16 ||\n T == VideoFormat::GXF_VIDEO_FORMAT_RGB32 || T == VideoFormat::GXF_VIDEO_FORMAT_BGR32>> {\n std::array defaultRGB() {\n if (T == VideoFormat::GXF_VIDEO_FORMAT_RGB) {\n return {ColorPlane(\"RGB\", 3)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_BGR) {\n return {ColorPlane(\"BGR\", 3)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_RGB16) {\n return {ColorPlane(\"RGB\", 3 * 2)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_BGR16) {\n return {ColorPlane(\"BGR\", 3 * 2)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_RGB32) {\n return {ColorPlane(\"RGB\", 3 * 4)};\n } else { // T == VideoFormat::GXF_VIDEO_FORMAT_BGR32\n return {ColorPlane(\"BGR\", 3 * 4)};\n }\n }\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_plane,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n color_plane[0].width = widthEven;\n color_plane[0].height = heightEven;\n color_plane[0].stride = ComputeStrides(stride_align, color_plane[0].width,\n color_plane[0].bytes_per_pixel, color_plane[0].stride);\n color_plane[0].size = color_plane[0].stride * color_plane[0].height;\n color_plane[0].offset = 0;\n return color_plane[0].size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto rgb = defaultRGB();\n fillColorPlanes(width, height, rgb, stride_align);\n std::vector result(rgb.begin(), rgb.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n auto rgb = defaultRGB();\n return fillColorPlanes(width, height, rgb, stride_align);\n }\n};\n\n// Specifies x-x-x(8/16/32) bit multi planar RGB/BGR variants\ntemplate \nstruct VideoFormatSize> {\n std::array defaultRGB() {\n if (T == VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8) {\n return {ColorPlane(\"R\", 1), ColorPlane(\"G\", 1), ColorPlane(\"B\", 1)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_B8_G8_R8) {\n return {ColorPlane(\"B\", 1), ColorPlane(\"G\", 1), ColorPlane(\"R\", 1)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16) {\n return {ColorPlane(\"R\", 2), ColorPlane(\"G\", 2), ColorPlane(\"B\", 2)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_B16_G16_R16) {\n return {ColorPlane(\"B\", 2), ColorPlane(\"G\", 2), ColorPlane(\"R\", 2)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32) {\n return {ColorPlane(\"R\", 4), ColorPlane(\"G\", 4), ColorPlane(\"B\", 4)};\n } else { // T == VideoFormat::GXF_VIDEO_FORMAT_B32_G32_R32\n return {ColorPlane(\"B\", 4), ColorPlane(\"G\", 4), ColorPlane(\"R\", 4)};\n }\n }\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_planes,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n\n uint64_t size = 0;\n for (size_t i = 0; i < color_planes.size(); ++i) {\n color_planes[i].width = widthEven;\n color_planes[i].height = heightEven;\n color_planes[i].stride = ComputeStrides(stride_align, color_planes[i].width,\n color_planes[i].bytes_per_pixel, color_planes[i].stride);\n color_planes[i].size = color_planes[i].stride * color_planes[i].height;\n color_planes[i].offset = size;\n size += color_planes[i].size;\n }\n return size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto rgb = defaultRGB();\n fillColorPlanes(width, height, rgb, stride_align);\n std::vector result(rgb.begin(), rgb.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n auto rgb = defaultRGB();\n return fillColorPlanes(width, height, rgb, stride_align);\n }\n};\n\n// Specifies x-x-x(8/16/32) bit multi planar RGBD variants\ntemplate \nstruct VideoFormatSize> {\n std::array defaultRGBD() {\n if (T == VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8_D8) {\n return {ColorPlane(\"R\", 1), ColorPlane(\"G\", 1), ColorPlane(\"B\", 1), ColorPlane(\"D\", 1)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16_D16) {\n return {ColorPlane(\"R\", 2), ColorPlane(\"G\", 2), ColorPlane(\"B\", 2), ColorPlane(\"D\", 2)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32_D32) {\n return {ColorPlane(\"R\", 4), ColorPlane(\"G\", 4), ColorPlane(\"B\", 4), ColorPlane(\"D\", 4)};\n }\n }\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_planes,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n\n uint64_t size = 0;\n for (size_t i = 0; i < color_planes.size(); ++i) {\n color_planes[i].width = widthEven;\n color_planes[i].height = heightEven;\n color_planes[i].stride = ComputeStrides(stride_align, color_planes[i].width,\n color_planes[i].bytes_per_pixel, color_planes[i].stride);\n color_planes[i].size = color_planes[i].stride * color_planes[i].height;\n color_planes[i].offset = size;\n size += color_planes[i].size;\n }\n return size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto rgbd = defaultRGBD();\n fillColorPlanes(width, height, rgbd, stride_align);\n std::vector result(rgbd.begin(), rgbd.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n auto rgbd = defaultRGBD();\n return fillColorPlanes(width, height, rgbd, stride_align);\n }\n};\n\n// Specifies x-x-x-x(8/16/32) bit float single plane RGBD variants\ntemplate \nstruct VideoFormatSize> {\n std::array defaultRGBD() {\n if (T == VideoFormat::GXF_VIDEO_FORMAT_RGBD8) {\n return {ColorPlane(\"RGBD\", 4)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_RGBD16) {\n return {ColorPlane(\"RGBD\", 8)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_RGBD32) {\n return {ColorPlane(\"RGBD\", 16)};\n }\n }\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_plane,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n\n color_plane[0].width = widthEven;\n color_plane[0].height = heightEven;\n color_plane[0].stride = ComputeStrides(stride_align, color_plane[0].width,\n color_plane[0].bytes_per_pixel, color_plane[0].stride);\n color_plane[0].size = color_plane[0].stride * color_plane[0].height;\n color_plane[0].offset = 0;\n return color_plane[0].size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto rgbd = defaultRGBD();\n fillColorPlanes(width, height, rgbd, stride_align);\n std::vector result(rgbd.begin(), rgbd.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n auto rgbd = defaultRGBD();\n return fillColorPlanes(width, height, rgbd, stride_align);\n }\n};\n\n// Specifies 32/64 bit float single plane Depth\ntemplate \nstruct VideoFormatSize> {\n std::array defaultDepth() {\n if (T == VideoFormat::GXF_VIDEO_FORMAT_D32F) {\n return {ColorPlane(\"D\", 4)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_D64F) {\n return {ColorPlane(\"D\", 8)};\n }\n }\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_plane,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n\n color_plane[0].width = widthEven;\n color_plane[0].height = heightEven;\n color_plane[0].stride = ComputeStrides(stride_align, color_plane[0].width,\n color_plane[0].bytes_per_pixel, color_plane[0].stride);\n color_plane[0].size = color_plane[0].stride * color_plane[0].height;\n color_plane[0].offset = 0;\n return color_plane[0].size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto depth = defaultDepth();\n fillColorPlanes(width, height, depth, stride_align);\n std::vector result(depth.begin(), depth.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_planes,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_planes, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n auto depth = defaultDepth();\n return fillColorPlanes(width, height, depth, stride_align);\n }\n};\n\n\n// Specifies x-x-x(8/16/32) bit single plane GRAY scale\ntemplate \nstruct VideoFormatSize> {\n std::array defaultGray() {\n if (T == VideoFormat::GXF_VIDEO_FORMAT_GRAY) {\n return {ColorPlane(\"gray\", 1)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_GRAY16) {\n return {ColorPlane(\"gray\", 2)};\n } else { // T == VideoFormat::GXF_VIDEO_FORMAT_GRAY32 & VideoFormat::GXF_VIDEO_FORMAT_GRAY32F\n return {ColorPlane(\"gray\", 4)};\n }\n }\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_plane,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n color_plane[0].width = widthEven;\n color_plane[0].height = heightEven;\n color_plane[0].stride = ComputeStrides(stride_align, color_plane[0].width,\n color_plane[0].bytes_per_pixel, color_plane[0].stride);\n color_plane[0].size = color_plane[0].stride * color_plane[0].height;\n color_plane[0].offset = 0;\n return color_plane[0].size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto gray = defaultGray();\n fillColorPlanes(width, height, gray, stride_align);\n std::vector result(gray.begin(), gray.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_plane,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_plane, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n auto gray = defaultGray();\n return fillColorPlanes(width, height, gray, stride_align);\n }\n};\n\n// Specifies x-x-x-x(16) bit single plane Bayer RAW16\ntemplate \nstruct VideoFormatSize> {\n std::array defaultBayerRaw16() {\n if (T == VideoFormat::GXF_VIDEO_FORMAT_RAW16_RGGB) {\n return {ColorPlane(\"Raw_RGGB\", 4 * 2)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_RAW16_BGGR) {\n return {ColorPlane(\"Raw_BGGR\", 4 * 2)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_RAW16_GRBG) {\n return {ColorPlane(\"Raw_GRBG\", 4 * 2)};\n } else if (T == VideoFormat::GXF_VIDEO_FORMAT_RAW16_GBRG) {\n return {ColorPlane(\"Raw_GBRG\", 4 * 2)};\n }\n }\n\n uint64_t fillColorPlanes(uint32_t width, uint32_t height,\n std::array& color_plane,\n bool stride_align = true) {\n uint32_t widthEven = AlignToEvenDimension(width);\n uint32_t heightEven = AlignToEvenDimension(height);\n color_plane[0].width = widthEven;\n color_plane[0].height = heightEven;\n color_plane[0].stride = ComputeStrides(stride_align, color_plane[0].width,\n color_plane[0].bytes_per_pixel, color_plane[0].stride);\n color_plane[0].size = color_plane[0].stride * color_plane[0].height;\n color_plane[0].offset = 0;\n return color_plane[0].size;\n }\n\n std::vector getDefaultColorPlanes(uint32_t width, uint32_t height,\n bool stride_align = true) {\n auto bayerRaw16 = defaultBayerRaw16();\n fillColorPlanes(width, height, bayerRaw16, stride_align);\n std::vector result(bayerRaw16.begin(), bayerRaw16.end());\n return result;\n }\n\n uint64_t size(uint32_t width, uint32_t height, std::array& color_plane,\n bool stride_align = true) {\n return fillColorPlanes(width, height, color_plane, stride_align);\n }\n\n uint64_t size(uint32_t width, uint32_t height, bool stride_align = true) {\n auto bayerRaw16 = defaultBayerRaw16();\n return fillColorPlanes(width, height, bayerRaw16, stride_align);\n }\n};\n\n// Descriptor for a VideoBuffer\nstruct VideoBufferInfo {\n // width of a video frame\n uint32_t width;\n // height of a video frame\n uint32_t height;\n // color format of a video frame\n VideoFormat color_format;\n // Color plane info\n std::vector color_planes;\n // surface memory layout of a video frame\n SurfaceLayout surface_layout;\n};\n\n// A media type which stores information corresponding to a video frame\n// resize(...) function is used to allocate memory for the video frame based on\n// height, width and color format of the frame\nclass VideoBuffer {\n public:\n VideoBuffer() = default;\n\n ~VideoBuffer() { memory_buffer_.freeBuffer(); }\n\n VideoBuffer(const VideoBuffer&) = delete;\n\n VideoBuffer(VideoBuffer&& other) { *this = std::move(other); }\n\n VideoBuffer& operator=(const VideoBuffer&) = delete;\n\n VideoBuffer& operator=(VideoBuffer&& other) {\n buffer_info_ = other.buffer_info_;\n memory_buffer_ = std::move(other.memory_buffer_);\n\n return *this;\n }\n\n // Resizes the video frame and allocates the corresponding memory with the allocator provided\n // Any data previously stored in the frame would be freed\n template \n Expected resize(uint32_t width, uint32_t height, SurfaceLayout layout,\n MemoryStorageType storage_type, Handle allocator,\n bool stride_align = true) {\n VideoTypeTraits video_type;\n VideoFormatSize color_format;\n uint64_t size = color_format.size(width, height, stride_align);\n auto color_planes = color_format.getDefaultColorPlanes(width, height, stride_align);\n VideoBufferInfo buffer_info{width, height, video_type.value, std::move(color_planes), layout};\n return resizeCustom(std::move(buffer_info), size, storage_type, allocator);\n }\n\n // Type of the callback function to release memory passed to the VideoFrame using the\n // wrapMemory method\n using release_function_t = MemoryBuffer::release_function_t;\n\n // Wrap existing memory inside the VideoBuffer. A callback function of type release_function_t\n // may be passed that will be called when the VideoBuffer wants to release the memory.\n Expected wrapMemory(VideoBufferInfo buffer_info, uint64_t size,\n MemoryStorageType storage_type, void* pointer,\n release_function_t release_func);\n\n // Moves the existing video buffer to a tensor element specified by the handle\n Expected moveToTensor(Handle& tensor);\n\n // Moves the existing video buffer to a tensor element specified by the pointer\n Expected moveToTensor(Tensor* tensor);\n\n // Moves memory buffer from tensor to video buffer works on rank 2 and 3 tensors,\n // ordering of dimensions in tensor is assumed to be [whc]\n // OBS: If successful, tensor destructor will be called and handle set to null\n template \n Expected createFromTensor(Handle& tensor, SurfaceLayout layout,\n bool stride_align = true);\n\n // VideoBufferInfo of the video frame\n VideoBufferInfo video_frame_info() const { return buffer_info_; }\n\n // The type of memory where the frame data is stored.\n MemoryStorageType storage_type() const { return memory_buffer_.storage_type(); }\n\n // Size of the video frame in bytes\n uint64_t size() const { return memory_buffer_.size(); }\n\n // Raw pointer to the first byte of the video frame\n byte* pointer() const { return memory_buffer_.pointer(); }\n\n // Resizes the video frame and allocates the corresponding memory with the allocator provided\n // Any data previously stored in the frame would be freed\n Expected resizeCustom(VideoBufferInfo buffer_info, uint64_t size,\n MemoryStorageType storage_type, Handle allocator);\n\n // Helper function to get primitive types for color formats that are valid (planar) for moving\n // from Tensor to VideoBuffer, and vice versa. If color_format is not valid,\n // PrimitiveType::kCustom is returned\n static Expected getPlanarPrimitiveType(VideoFormat color_format) {\n PrimitiveType primitive_type;\n switch (color_format) {\n case VideoFormat::GXF_VIDEO_FORMAT_NV12: // BT.601 2 planes Y, UV\n case VideoFormat::GXF_VIDEO_FORMAT_RGBA: // RGBA-8-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_BGRA: // BGRA-8-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_ARGB: // ARGB-8-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_ABGR: // ABGR-8-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_RGBX: // RGBX-8-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_BGRX: // BGRX-8-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_XRGB: // XRGB-8-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_XBGR: // XBGR-8-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_RGB: // RGB-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_BGR: // BGR-8-8-8 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8: // RGB - unsigned 8 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_B8_G8_R8: // BGR - unsigned 8 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8_D8: // RGBD unsigned 8 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_RGBD8: // RGBD 8 bit unsigned single plane\n case VideoFormat::GXF_VIDEO_FORMAT_GRAY: { // 8 bit GRAY scale single plane\n primitive_type = PrimitiveType::kUnsigned8;\n } break;\n\n case VideoFormat::GXF_VIDEO_FORMAT_GRAY16: // 16 bit GRAY scale single plane\n case VideoFormat::GXF_VIDEO_FORMAT_RGB16: // RGB-16-16-16 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_BGR16: // BGR-16-16-16 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16: // RGB unsigned 16 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_B16_G16_R16: // BGR unsigned 16 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16_D16: // RGBD unsigned 16 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_RGBD16: { // RGBD 16 bit unsigned single plane\n primitive_type = PrimitiveType::kUnsigned16;\n } break;\n\n case VideoFormat::GXF_VIDEO_FORMAT_GRAY32: // 32 bit GRAY scale single plane\n case VideoFormat::GXF_VIDEO_FORMAT_RGB32: // RGB-32-32-32 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_BGR32: // BGR-32-32-32 single plane\n case VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32: // RGB unsigned 32 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_B32_G32_R32: // BGR unsigned 32 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32_D32: // RGBD unsigned 32 bit multiplanar\n case VideoFormat::GXF_VIDEO_FORMAT_RGBD32: { // RGBD 32 bit unsigned single plane\n primitive_type = PrimitiveType::kUnsigned32;\n } break;\n\n case VideoFormat::GXF_VIDEO_FORMAT_D32F: // Depth 32 bit float single plane\n case VideoFormat::GXF_VIDEO_FORMAT_GRAY32F: { // GRAY 32 bit float single plane\n primitive_type = PrimitiveType::kFloat32;\n } break;\n\n case VideoFormat::GXF_VIDEO_FORMAT_D64F: { // Depth 64 bit float single plane\n primitive_type = PrimitiveType::kFloat64;\n } break;\n\n case VideoFormat::GXF_VIDEO_FORMAT_CUSTOM: { // CUSTOM undefined\n primitive_type = PrimitiveType::kCustom;\n } break;\n\n default: { // Non-planar type given\n GXF_LOG_ERROR(\"VideoFormat is of non-planar color format (%ld),\"\n \" which cannot be moved from tensor\", static_cast(color_format));\n return Unexpected{GXF_INVALID_DATA_FORMAT};\n } break;\n }\n\n return primitive_type;\n }\n\n private:\n VideoBufferInfo buffer_info_;\n MemoryBuffer memory_buffer_;\n};\n\ntemplate \nExpected VideoBuffer::createFromTensor(Handle& tensor,\n SurfaceLayout layout,\n bool stride_align) {\n if (!tensor) {\n GXF_LOG_ERROR(\"createFromTensor received invalid tensor handle\");\n return Unexpected{GXF_ARGUMENT_NULL};\n }\n\n // Tensor must have rank 2 (single-plane image) or 3 (multi-plane image)\n const uint32_t rank = tensor->rank();\n if ((rank < 2) || (rank > 3)) {\n GXF_LOG_ERROR(\"Tensor cannot be moved to VideoBuffer.\"\n \" Invalid rank=[%d], should be 2 or 3\", rank);\n return Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n\n // Get primitive type and sanity check color format\n VideoTypeTraits video_type;\n VideoFormatSize color_format;\n Expected primitive_type = getPlanarPrimitiveType(video_type.value);\n if (!primitive_type) { return ForwardError(primitive_type); }\n\n // Ensure video buffer and tensor has same data type\n PrimitiveType primite_type_tensor = tensor->element_type();\n\n if (primitive_type.value() != primite_type_tensor) {\n GXF_LOG_ERROR(\"Type of video buffer (%d) is different from\"\n \" type of tensor (%d)\", static_cast(primitive_type.value()),\n static_cast(primite_type_tensor));\n return Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n\n // Get tensor dimensions\n auto width = static_cast(tensor->shape().dimension(0));\n auto height = static_cast(tensor->shape().dimension(1));\n auto channels = static_cast(tensor->shape().dimension(2));\n\n // Get color planes\n auto color_planes = color_format.getDefaultColorPlanes(width, height, stride_align);\n\n // Sanity check that number of tensor channels corresponds to video format\n if (channels != color_planes.size()) {\n GXF_LOG_ERROR(\"Number of channels in tensor (%u) is \"\n \" different from video buffer (%lu)\", channels, color_planes.size());\n return Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n\n // Set buffer info\n VideoBufferInfo buffer_info{width, height, video_type.value, std::move(color_planes), layout};\n buffer_info_ = std::move(buffer_info);\n\n // Move memory buffer\n memory_buffer_ = tensor->move_buffer();\n\n // Explicit call to destructor as tensor is no longer usable (also set to Null handle)\n tensor->~Tensor();\n tensor = Handle::Null();\n\n return Success;\n}\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_MULTIMEDIA_VIDEO_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_client.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_NETWORK_TCP_CLIENT_HPP_\n#define NVIDIA_GXF_NETWORK_TCP_CLIENT_HPP_\n\n#include \"gxf/network/tcp_codelet.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Codelet that functions as a client in a TCP connection\nclass TcpClient : public TcpCodelet {\n protected:\n Expected openSockets() override;\n Expected reconnectSockets() override;\n Expected closeSockets() override;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_NETWORK_TCP_CLIENT_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_client_socket.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_NETWORK_TCP_CLIENT_SOCKET_HPP_\n#define NVIDIA_GXF_NETWORK_TCP_CLIENT_SOCKET_HPP_\n\n#include \n\n#include \n#include \n\n#include \"gxf/serialization/endpoint.hpp\"\n#include \"gxf/serialization/entity_serializer.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Header containing metadata for TCP packets\n#pragma pack(push, 1)\nstruct TcpHeader {\n uint64_t payload_size; // Size of the payload in bytes\n uint64_t entity_count; // Number of entities in the payload\n};\n#pragma pack(pop)\n\n// Header containing metadata for entities\n#pragma pack(push, 1)\nstruct MessageHeader {\n uint64_t channel_id; // Hashed channel name\n};\n#pragma pack(pop)\n\n// TCP message consisting of a header and an entity\nstruct TcpMessage {\n MessageHeader header;\n Entity entity;\n};\n\n// Endpoint for exchanging data over a TCP connection.\n// Connection must be established prior to use.\n// Packets are organized in the following format:\n//\n// | TCP Header || Message Header | Entity | ... | ... |\n//\n// Each entity will have a header prepended to form a message.\n// Messages will be grouped together to form the packet.\n// Little-endian is used over big-endian for better performance on x86 and arm platforms.\nclass TcpClientSocket : public Endpoint {\n public:\n TcpClientSocket() = default;\n ~TcpClientSocket() = default;\n TcpClientSocket(const TcpClientSocket& other) = delete;\n TcpClientSocket(TcpClientSocket&& other) { *this = std::move(other); }\n TcpClientSocket& operator=(const TcpClientSocket& other) = delete;\n TcpClientSocket& operator=(TcpClientSocket&& other) {\n fd_socket_ = other.fd_socket_;\n connected_ = other.connected_;\n maximum_attempts_ = other.maximum_attempts_;\n other.fd_socket_ = -1;\n other.connected_ = false;\n other.maximum_attempts_ = 1;\n return *this;\n }\n\n Expected open();\n Expected close();\n\n gxf_result_t write_abi(const void* data, size_t size, size_t* bytes_written) override;\n gxf_result_t read_abi(void* data, size_t size, size_t* bytes_read) override;\n\n // Initializes endpoint with a connected socket.\n // This is used by TcpServerSocket when establishing a connection.\n Expected openConnectedSocket(int socket);\n // Closes and reopens socket to enable reconnecting.\n // Socket needs to be reset after disconnecting to be used again.\n Expected reopenSocket();\n // Configures the maximum number of attempts\n void setMaximumAttempts(size_t attempts) { maximum_attempts_ = attempts; }\n // Returns true if the socket has data available for reading\n bool available() const;\n // Returns true if the socket is connected\n bool connected() const { return connected_; }\n // Attempts to connect to a TCP server at the given IP address.\n // Call will fail if IP address is invalid or server is unreachable.\n Expected connect(const char* address, uint16_t port);\n\n // Sends a set of messages via TCP\n Expected sendMessages(const std::vector& messages,\n EntitySerializer* serializer);\n // Receives a set of messages via TCP\n Expected> receiveMessages(gxf_context_t context,\n EntitySerializer* serializer);\n\n private:\n // Sends a message to the socket\n Expected sendMessage(const TcpMessage& message, EntitySerializer* serializer);\n // Receives a message from the socket\n Expected receiveMessage(gxf_context_t context, EntitySerializer* serializer);\n // Sends a TCP header to the socket\n Expected sendTcpHeader(TcpHeader header);\n // Receives a TCP header from the socket\n Expected receiveTcpHeader();\n // Sends a message header to the socket\n Expected sendMessageHeader(MessageHeader header);\n // Receives a message header from the socket\n Expected receiveMessageHeader();\n\n // Socket file descriptor\n int fd_socket_{-1};\n\n // TCP connection state\n bool connected_{false};\n // Maximum number of attempts for each I/O operation\n size_t maximum_attempts_{1};\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_NETWORK_TCP_CLIENT_SOCKET_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_codelet.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_NETWORK_TCP_CODELET_HPP_\n#define NVIDIA_GXF_NETWORK_TCP_CODELET_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"gxf/network/tcp_server_socket.hpp\"\n#include \"gxf/serialization/entity_serializer.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Abstract codelet supporting asynchronous TCP client/server\nclass TcpCodelet : public Codelet {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n\n gxf_result_t tick() override;\n gxf_result_t stop() override;\n\n protected:\n // Asynchronously monitors client socket and receivers. If data is available from either source,\n // schedules the TcpServer via the AsynchronousSchedulingTerm. Also handles connecting client\n // socket.\n Expected monitor();\n\n virtual Expected openSockets() = 0;\n virtual Expected reconnectSockets() = 0;\n virtual Expected closeSockets() = 0;\n\n Parameter>> receivers_;\n Parameter>> transmitters_;\n Parameter> entity_serializer_;\n Parameter address_;\n Parameter port_;\n Parameter timeout_ms_;\n Parameter timeout_text_;\n Parameter maximum_attempts_;\n Parameter max_msg_delay_ms_;\n Parameter max_duration_ms_;\n Parameter max_connection_attempts_;\n Parameter> async_scheduling_term_;\n\n int64_t timeout_ns_;\n\n // Maps channel IDs to transmitters\n std::unordered_map> channel_map_;\n // TCP client socket\n TcpClientSocket client_socket_;\n // Tracks monitor thread result\n std::future> monitor_future_;\n // Stores receivers with available data\n std::vector> available_receivers_;\n // Stores messages read from receivers\n std::vector rx_messages_;\n // Stores messages read from socket\n std::vector tx_messages_;\n // Time when last message was received\n Expected> last_msg_timestamp_ =\n Unexpected{GXF_UNINITIALIZED_VALUE};\n // Time when monitor thread began\n Expected> monitor_start_timestamp_ =\n Unexpected{GXF_UNINITIALIZED_VALUE};\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_NETWORK_TCP_CODELET_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_server.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_NETWORK_TCP_SERVER_HPP_\n#define NVIDIA_GXF_NETWORK_TCP_SERVER_HPP_\n\n#include \n#include \n#include \n\n#include \"gxf/network/tcp_codelet.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Codelet that functions as a server in a TCP connection\nclass TcpServer : public TcpCodelet {\n protected:\n Expected openSockets() override;\n Expected reconnectSockets() override;\n Expected closeSockets() override;\n\n private:\n // TCP server socket\n TcpServerSocket server_socket_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_NETWORK_TCP_SERVER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_server_socket.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_NETWORK_TCP_SERVER_SOCKET_HPP_\n#define NVIDIA_GXF_NETWORK_TCP_SERVER_SOCKET_HPP_\n\n#include \n\n#include \"gxf/network/tcp_client_socket.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Object for managing a TCP socket on the server side.\n// Connection must be established prior to use.\n// Uses a TcpClientSocket as a proxy for communication.\nclass TcpServerSocket {\n public:\n TcpServerSocket(const char* address, uint16_t port)\n : address_{address}, port_{port}, socket_{-1} {}\n TcpServerSocket() : address_{\"0.0.0.0\"}, port_{0}, socket_{-1} {}\n ~TcpServerSocket() = default;\n TcpServerSocket(const TcpServerSocket& other) = delete;\n TcpServerSocket(TcpServerSocket&& other) = default;\n TcpServerSocket& operator=(const TcpServerSocket& other) = delete;\n TcpServerSocket& operator=(TcpServerSocket&& other) = default;\n\n // Initializes server socket.\n // Creates socket file descriptor.\n // Binds IP address to socket.\n // Listens for incoming connections on socket.\n Expected open();\n // Deinitializes server socket.\n // Destroys socket file descriptor.\n Expected close();\n // Attempts to connect to a TCP client.\n // Returns a TCP client socket that can be used as an endpoint.\n // Call will fail if there are no clients requesting to connect.\n Expected connect();\n\n private:\n // Server address\n std::string address_;\n // Server port\n uint16_t port_;\n // Socket file descriptor\n int socket_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_NETWORK_TCP_SERVER_SOCKET_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/npp/nppi_mul_c.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_NPP_NPPI_MUL_C_HPP\n#define NVIDIA_GXF_NPP_NPPI_MUL_C_HPP\n\n#include \n\n#include \"gxf/core/parameter_parser_std.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Multiplies a CUDA tensor with a constant factor using NPP.\nclass NppiMulC : public Codelet {\n public:\n virtual ~NppiMulC() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t tick() override;\n\n private:\n Parameter> in_;\n Parameter> factor_;\n Parameter> pool_;\n Parameter> out_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/npp/nppi_set.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_NPP_NPPI_SET_HPP\n#define NVIDIA_GXF_NPP_NPPI_SET_HPP\n\n#include \n#include \n\n#include \"gxf/core/parameter_parser_std.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Creates a CUDA tensor with constant values using NPP.\nclass NppiSet : public Codelet {\n public:\n virtual ~NppiSet() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t tick() override;\n\n private:\n Parameter rows_;\n Parameter columns_;\n Parameter channels_;\n Parameter> pool_;\n Parameter> value_;\n Parameter> out_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/rmm/rmm_allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_RMM_RMM_ALLOCATOR_HPP_\n#define NVIDIA_GXF_RMM_RMM_ALLOCATOR_HPP_\n\n#include \n#include \n\n#include \n#include // NOLINT\n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"common/logger.hpp\"\n#include \"gxf/core/parameter.hpp\"\n#include \"gxf/cuda/cuda_allocator.hpp\"\n#include \"gxf/std/resources.hpp\"\n#include \"rmm/device_buffer.hpp\"\n#include \"rmm/mr/device/cuda_async_memory_resource.hpp\"\n#include \"rmm/mr/device/pool_memory_resource.hpp\"\n#include \"rmm/mr/host/pinned_memory_resource.hpp\"\nnamespace nvidia {\nnamespace gxf {\n\n// RMM based device memory allocator\nclass RMMAllocator : public CudaAllocator {\n public:\n RMMAllocator() = default;\n ~RMMAllocator() = default;\n\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t is_available_abi(uint64_t size) override;\n gxf_result_t is_rmm_available_abi(uint64_t size, MemoryStorageType type);\n gxf_result_t allocate_abi(uint64_t size, int32_t storage_type, void** pointer) override;\n gxf_result_t allocate_async_abi(uint64_t size, void** pointer,\n cudaStream_t stream) override;\n gxf_result_t free_async_abi(void* pointer, cudaStream_t stream) override;\n gxf_result_t free_abi(void* pointer) override;\n\n Expected get_pool_size(MemoryStorageType type) const override;\n\n private:\n Parameter device_memory_initial_size_;\n Parameter device_memory_max_size_;\n Parameter host_memory_initial_size_;\n Parameter host_memory_max_size_;\n Resource> gpu_device_;\n\n AllocatorStage stage_{AllocatorStage::kUninitialized};\n cudaStream_t stream_ = {};\n size_t device_max_memory_pool_size_;\n size_t host_max_memory_pool_size_;\n\n // Create a CUDA memory resource\n std::unique_ptr device_mr_;\n std::unique_ptr> pool_mr_device_;\n std::unique_ptr pinned_mr_;\n std::unique_ptr> pool_mr_host_;\n\n mutable std::shared_mutex shared_mutex_;\n std::unordered_map> pool_map_ = {};\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_RMM_RMM_ALLOCATOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/component_serializer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_COMPONENT_SERIALIZER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_COMPONENT_SERIALIZER_HPP_\n\n#include \n#include // NOLINT\n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/serialization/endpoint.hpp\"\n#include \"gxf/serialization/tid_hash.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Interface for serializing components\nclass ComponentSerializer : public Component {\n public:\n virtual ~ComponentSerializer() = default;\n\n // Checks if the serializer supports the given component type\n // Searches serializer map by default\n virtual gxf_result_t is_supported_abi(gxf_tid_t tid) {\n return getSerializer(tid) ? GXF_SUCCESS : GXF_FAILURE;\n }\n // Serializes component and writes to endpoint\n // Returns the size of the serialized component in bytes\n // Uses functions in serializer map by default\n virtual gxf_result_t serialize_component_abi(gxf_uid_t cid, Endpoint* endpoint, uint64_t* size);\n // Reads from endpoint and deserializes component\n // Uses functions in serializer map by default\n virtual gxf_result_t deserialize_component_abi(gxf_uid_t cid, Endpoint* endpoint);\n\n // C++ API wrappers\n bool isSupported(gxf_tid_t tid) { return is_supported_abi(tid) == GXF_SUCCESS; }\n Expected serializeComponent(UntypedHandle component, Endpoint* endpoint);\n Expected deserializeComponent(UntypedHandle component, Endpoint* endpoint);\n\n protected:\n // Serializer function handle\n // Takes a component pointer and an endpoint pointer as input\n // Returns the size of the serialized component in bytes\n using Serializer = std::function(void*, Endpoint*)>;\n // Deserializer function handle\n // Takes a component pointer and an endpoint pointer as input\n using Deserializer = std::function(void*, Endpoint*)>;\n\n // Returns a serializer for the given type ID\n Expected getSerializer(gxf_tid_t tid) const;\n // Returns a deserializer for the given type ID\n Expected getDeserializer(gxf_tid_t tid) const;\n // Adds a serializer for the given type ID\n Expected setSerializer(gxf_tid_t tid, Serializer serializer);\n // Adds a deserializer for the given type ID\n Expected setDeserializer(gxf_tid_t tid, Deserializer deserializer);\n // Removes a serializer for the given type ID\n Expected clearSerializer(gxf_tid_t tid) { return setSerializer(tid, nullptr); }\n // Removes a deserializer for the given type ID\n Expected clearDeserializer(gxf_tid_t tid) { return setDeserializer(tid, nullptr); }\n\n // Returns a serializer for the given type\n template \n Expected getSerializer() const {\n gxf_tid_t tid;\n return ExpectedOrCode(GxfComponentTypeId(context(), TypenameAsString(), &tid))\n .and_then([&](){ return getSerializer(tid); });\n }\n // Returns a deserializer for the given type\n template \n Expected getDeserializer() const {\n gxf_tid_t tid;\n return ExpectedOrCode(GxfComponentTypeId(context(), TypenameAsString(), &tid))\n .and_then([&](){ return getDeserializer(tid); });\n }\n // Adds a serializer for the given type\n template \n Expected setSerializer(Serializer serializer) {\n gxf_tid_t tid;\n return ExpectedOrCode(GxfComponentTypeId(context(), TypenameAsString(), &tid))\n .and_then([&](){ return setSerializer(tid, serializer); });\n }\n // Adds a deserializer for the given type\n template \n Expected setDeserializer(Deserializer deserializer) {\n gxf_tid_t tid;\n return ExpectedOrCode(GxfComponentTypeId(context(), TypenameAsString(), &tid))\n .and_then([&](){ return setDeserializer(tid, deserializer); });\n }\n // Removes a serializer for the given type\n template \n Expected clearSerializer(Serializer serializer) {\n gxf_tid_t tid;\n return ExpectedOrCode(GxfComponentTypeId(context(), TypenameAsString(), &tid))\n .and_then([&](){ return clearSerializer(tid); });\n }\n // Removes a deserializer for the given type\n template \n Expected clearDeserializer(Deserializer deserializer) {\n gxf_tid_t tid;\n return ExpectedOrCode(GxfComponentTypeId(context(), TypenameAsString(), &tid))\n .and_then([&](){ return clearDeserializer(tid); });\n }\n\n private:\n // Structure for organizing serialize-deserialize function pairs\n struct SerializerFunctions {\n Serializer serializer;\n Deserializer deserializer;\n };\n\n // Table that maps component type ID to serializer functions\n std::unordered_map serializer_map_;\n // Mutex to guard concurrent access to serializer map\n mutable std::shared_timed_mutex mutex_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_COMPONENT_SERIALIZER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/endpoint.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_ENDPOINT_HPP_\n#define NVIDIA_GXF_SERIALIZATION_ENDPOINT_HPP_\n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/std/allocator.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Interface for exchanging data external to an application graph\nclass Endpoint : public Component {\n public:\n virtual ~Endpoint() = default;\n\n // Returns `GXF_SUCCESS` if endpoint can be written to\n virtual gxf_result_t is_write_available_abi() { return GXF_SUCCESS; }\n // Returns `GXF_SUCCESS` if endpoint can be read from\n virtual gxf_result_t is_read_available_abi() { return GXF_SUCCESS; }\n // Writes data to the endpoint and returns the number of bytes written\n virtual gxf_result_t write_abi(const void* data, size_t size, size_t* bytes_written) = 0;\n // Reads data from the endpoint and returns the number of bytes read\n virtual gxf_result_t read_abi(void* data, size_t size, size_t* bytes_read) = 0;\n // Writes pointer to the data and size of the data to a vector\n virtual gxf_result_t write_ptr_abi(const void* pointer, size_t size, MemoryStorageType type) {\n return GXF_NOT_IMPLEMENTED;\n }\n\n // C++ API wrappers\n bool isWriteAvailable();\n bool isReadAvailable();\n Expected write(const void* data, size_t size);\n Expected read(void* data, size_t size);\n Expected write_ptr(const void* pointer, size_t size, MemoryStorageType type);\n\n // Writes an object of type T to the endpoint\n template \n Expected writeTrivialType(const T* object) { return write(object, sizeof(T)); }\n\n // Reads an object of type T from the endpoint\n template \n Expected readTrivialType(T* object) { return read(object, sizeof(T)); }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_ENDPOINT_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_recorder.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_ENTITY_RECORDER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_ENTITY_RECORDER_HPP_\n\n#include \n\n#include \"gxf/serialization/entity_serializer.hpp\"\n#include \"gxf/serialization/file_stream.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Records incoming entities by serializaing and writing to a file.\n// Uses one file to store binary data and a second file as an index to enable random-access.\nclass EntityRecorder : public Codelet {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n gxf_result_t tick() override;\n\n private:\n Parameter> receiver_;\n Parameter> entity_serializer_;\n Parameter directory_;\n Parameter basename_;\n Parameter flush_on_tick_;\n\n // File stream for data index\n FileStream index_file_stream_;\n // File stream for binary data\n FileStream binary_file_stream_;\n // Offset into binary file\n size_t binary_file_offset_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_ENTITY_RECORDER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_replayer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_ENTITY_REPLAYER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_ENTITY_REPLAYER_HPP_\n\n#include \n\n#include \"gxf/serialization/entity_serializer.hpp\"\n#include \"gxf/serialization/file_stream.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/scheduling_terms.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Replays entities by reading and deserializing from a file.\n// The file is processed sequentially and a single entity is published per tick.\nclass EntityReplayer : public Codelet {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n gxf_result_t tick() override;\n\n private:\n Parameter> transmitter_;\n Parameter> entity_serializer_;\n Parameter> boolean_scheduling_term_;\n Parameter directory_;\n Parameter basename_;\n Parameter batch_size_;\n Parameter ignore_corrupted_entities_;\n\n // File stream for entities\n FileStream entity_file_stream_;\n // File stream for index\n FileStream index_file_stream_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_ENTITY_REPLAYER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_serializer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_ENTITY_SERIALIZER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_ENTITY_SERIALIZER_HPP_\n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/serialization/endpoint.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Interface for serializing entities\nclass EntitySerializer : public Component {\n public:\n virtual ~EntitySerializer() = default;\n\n // Deserializes a received entity.\n // Returns the deserialized entity.\n virtual Expected deserialize_entity_header_abi(\n Endpoint* endpoint) = 0;\n\n // Serializes entity and writes to endpoint\n // Returns the size of the serialized entity in bytes\n virtual gxf_result_t serialize_entity_abi(gxf_uid_t eid, Endpoint* endpoint, uint64_t* size) = 0;\n // Reads from endpoint and deserializes entity\n virtual gxf_result_t deserialize_entity_abi(gxf_uid_t eid, Endpoint* endpoint) = 0;\n\n // C++ API wrappers\n Expected serializeEntity(Entity entity, Endpoint* endpoint);\n Expected deserializeEntity(Entity entity, Endpoint* endpoint);\n\n Expected deserializeEntity(gxf_context_t context, Endpoint* endpoint);\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_ENTITY_SERIALIZER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/file.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_FILE_HPP_\n#define NVIDIA_GXF_SERIALIZATION_FILE_HPP_\n\n#include \n#include \n#include \n\n#include \"gxf/serialization/endpoint.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/memory_buffer.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Wrapper around C file I/O API\nclass File : public Endpoint {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n\n gxf_result_t write_abi(const void* data, size_t size, size_t* bytes_written) override;\n gxf_result_t read_abi(void* data, size_t size, size_t* bytes_read) override;\n\n // Opens a file with the given mode\n // Uses parameter values if arguments are not specified\n Expected open(const char* path = nullptr, const char* mode = nullptr);\n // Closes the opened file\n Expected close();\n // Clears the end-of-file and error indicators\n void clear();\n // Returns true if the end-of-file indicator is set\n bool eof();\n // Returns true if the error indicator is set\n bool error();\n // Flushes the output buffer of the file stream\n Expected flush();\n // Sets the file position to the given offset\n Expected seek(int offset, int position = SEEK_SET);\n // Returns the current file position\n Expected tell();\n // Returns true if the file is open\n bool isOpen();\n // Returns the configured file path\n const char* path();\n // Returns the configured file mode\n const char* mode();\n // Renames the file\n Expected rename(const char* path);\n // Prepends a timestamp to the file name\n // Uses local time zone by default and UTC if specified\n Expected addTimestamp(int64_t timestamp, bool utc = false);\n // Write-protects the file\n Expected writeProtect();\n\n private:\n Parameter> allocator_;\n Parameter file_path_;\n Parameter file_mode_;\n Parameter buffer_size_;\n\n // File stream\n std::FILE* file_;\n // Stream buffer\n MemoryBuffer buffer_;\n // Mutex to guard concurrent access\n mutable std::recursive_mutex mutex_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_FILE_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/file_stream.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_FILE_STREAM_HPP_\n#define NVIDIA_GXF_SERIALIZATION_FILE_STREAM_HPP_\n\n#include \n#include \n#include \n\n#include \"gxf/serialization/endpoint.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n#pragma pack(push, 1)\nstruct EntityIndex {\n uint64_t log_time; // Time when data was logged\n uint64_t data_size; // Size of data block\n uint64_t data_offset; // Location of data block\n};\n#pragma pack(pop)\n\n// Graph endpoint that exchanges data using files\n// Input file path is used for reading (empty string to disable reading)\n// Output file path is used for writing (empty string to disable writing)\n// The same file can be used for both reading and writing\nclass FileStream : public Endpoint {\n public:\n // Extension for index files\n static constexpr const char* kIndexFileExtension = \".gxf_index\";\n // Extension for binary files\n static constexpr const char* kBinaryFileExtension = \".gxf_entities\";\n\n FileStream(std::string input_file, std::string output_file)\n : input_file_path_{std::move(input_file)}, output_file_path_{std::move(output_file)} {}\n FileStream() = default;\n ~FileStream() = default;\n FileStream(const FileStream& other) = delete;\n FileStream(FileStream&& other) { *this = std::move(other); }\n FileStream& operator=(const FileStream& other) = delete;\n FileStream& operator=(FileStream&& other) {\n input_file_path_ = std::move(other.input_file_path_);\n output_file_path_ = std::move(other.output_file_path_);\n input_file_ = std::move(other.input_file_);\n output_file_ = std::move(other.output_file_);\n return *this;\n }\n\n Expected open();\n Expected close();\n\n gxf_result_t write_abi(const void* data, size_t size, size_t* bytes_written) override;\n gxf_result_t read_abi(void* data, size_t size, size_t* bytes_read) override;\n\n // Clears error state flags for input and output streams\n void clear();\n // Flushes output stream buffer to file\n // Returns an error if operation failed\n Expected flush();\n // Moves the output stream to the desired position\n Expected setWriteOffset(size_t index);\n // Returns the current position of the output stream\n Expected getWriteOffset();\n // Moves the input stream to the desired position\n Expected setReadOffset(size_t index);\n // Returns the current position of the input stream\n Expected getReadOffset();\n\n private:\n // Path to input file\n std::string input_file_path_;\n // Path to output file\n std::string output_file_path_;\n // Input file stream\n std::ifstream input_file_;\n // Output file stream\n std::ofstream output_file_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_FILE_STREAM_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/serialization_buffer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_SERIALIZATION_BUFFER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_SERIALIZATION_BUFFER_HPP_\n\n#include \n\n#include \"gxf/serialization/endpoint.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/memory_buffer.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Buffer to hold serialized data\nclass SerializationBuffer : public Endpoint {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override { return ToResultCode(buffer_.freeBuffer()); }\n\n gxf_result_t write_abi(const void* data, size_t size, size_t* bytes_written) override;\n gxf_result_t read_abi(void* data, size_t size, size_t* bytes_read) override;\n\n // Resizes the buffer\n Expected resize(size_t size, MemoryStorageType storage_type);\n\n // Type of the callback function to release memory passed to the SerializationBuffer\n // using the wrapMemory method\n using release_function_t = MemoryBuffer::release_function_t;\n\n // Wrap existing memory inside the SerializationBuffer.\n // A callback function of type release_function_t may be passed that will be called when the\n // SerializationBuffer wants to release the memory.\n Expected wrapMemory(void* pointer, uint64_t size,\n MemoryStorageType storage_type,\n release_function_t release_func);\n\n // The type of memory where the data is stored\n MemoryStorageType storage_type() const { return buffer_.storage_type(); }\n // Returns a read-only pointer to buffer data\n const byte* data() const { return buffer_.pointer(); }\n // Returns the capacity of the buffer\n size_t capacity() const { return buffer_.size(); }\n // Returns the number of bytes written to the buffer\n size_t size() const;\n // Resets buffer for sequential access\n void reset();\n\n private:\n Parameter> allocator_;\n Parameter buffer_size_;\n Parameter storage_type_;\n\n // Data buffer\n MemoryBuffer buffer_;\n // Offset for sequential writes\n size_t write_offset_;\n // Offset for sequential reads\n size_t read_offset_;\n // Mutex to guard concurrent access\n mutable std::mutex mutex_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_SERIALIZATION_BUFFER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/std_component_serializer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_STD_COMPONENT_SERIALIZER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_STD_COMPONENT_SERIALIZER_HPP_\n\n#include\n\n#include \"common/endian.hpp\"\n#include \"gxf/cuda/cuda_common.hpp\"\n#include \"gxf/serialization/component_serializer.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/tensor.hpp\"\n#include \"gxf/std/timestamp.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Serializer that supports serializaing Timestamps, Tensors, and integer components\n// Valid for sharing data between devices with the same endianness\nclass StdComponentSerializer : public ComponentSerializer {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override { return GXF_SUCCESS; }\n\n private:\n // Configures all serializer functions\n Expected configureSerializers();\n // Configures all deserializer functions\n Expected configureDeserializers();\n // Serializes a nvidia::gxf::Timestamp\n Expected serializeTimestamp(Timestamp timestamp, Endpoint* endpoint);\n // Deserializes a nvidia::gxf::Timestamp\n Expected deserializeTimestamp(Endpoint* endpoint);\n // Serializes a nvidia::gxf::Tensor\n Expected serializeTensor(const Tensor& tensor, Endpoint* endpoint);\n // Deserializes a nvidia::gxf::Tensor\n Expected deserializeTensor(Endpoint* endpoint);\n // Serializes an integer\n template \n Expected serializeInteger(T value, Endpoint* endpoint) {\n if (!endpoint) {\n return Unexpected{GXF_ARGUMENT_NULL};\n }\n T encoded = EncodeLittleEndian(value);\n return endpoint->writeTrivialType(&encoded);\n }\n // Deserializes an integer\n template \n Expected deserializeInteger(Endpoint* endpoint) {\n if (!endpoint) {\n return Unexpected{GXF_ARGUMENT_NULL};\n }\n T encoded;\n return endpoint->readTrivialType(&encoded)\n .and_then([&]() { return DecodeLittleEndian(encoded); });\n }\n\n Parameter> allocator_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_STD_COMPONENT_SERIALIZER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/std_entity_id_serializer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_STD_ENTITY_ID_SERIALIZER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_STD_ENTITY_ID_SERIALIZER_HPP_\n\n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"gxf/serialization/entity_serializer.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Serializes and deserializes entity id. No component serializer used.\n\nclass StdEntityIdSerializer : public EntitySerializer {\n public:\n#pragma pack(push, 1)\n struct EntityHeader {\n uint64_t entity_id;\n uint64_t sequence_number;\n };\n#pragma pack(pop)\n\n gxf_result_t initialize() override { return GXF_SUCCESS; }\n gxf_result_t deinitialize() override { return GXF_SUCCESS; }\n\n Expected deserialize_entity_header_abi(Endpoint* endpoint) override;\n\n gxf_result_t serialize_entity_abi(gxf_uid_t eid, Endpoint* endpoint,\n uint64_t* size) override;\n gxf_result_t deserialize_entity_abi(gxf_uid_t eid,\n Endpoint* endpoint) override;\n\n private:\n // Sequence number for outgoing messages\n uint64_t outgoing_sequence_number_{0};\n // Sequence number for incoming messages\n uint64_t incoming_sequence_number_{0};\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_STD_ENTITY_ID_SERIALIZER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/std_entity_serializer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_STD_ENTITY_SERIALIZER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_STD_ENTITY_SERIALIZER_HPP_\n\n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"gxf/serialization/component_serializer.hpp\"\n#include \"gxf/serialization/entity_serializer.hpp\"\n#include \"gxf/serialization/tid_hash.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Serializes and deserializes entities with the provided component serializers\n// Little-endian is used over big-endian for better performance on x86 and arm platforms\n// Entities are serialized in the following format:\n//\n// | Entity Header || Component Header | Component Name | Component | ... | ... | ... |\n//\n// Components will be serialized in the order they are added to the entity\n// Components without serializers will be skipped\n// Each component will be preceded by a component header and the name of the component\n// The component itself will be serialized with a component serializer\n// An entity header will be added at the beginning\nclass StdEntitySerializer : EntitySerializer {\n public:\n #pragma pack(push, 1)\n // Header preceding entities\n struct EntityHeader {\n uint64_t serialized_size; // Size of the serialized entity in bytes\n uint32_t checksum; // Checksum to verify the integrity of the message\n uint64_t sequence_number; // Sequence number of the message\n uint32_t flags; // Flags to specify delivery options\n uint64_t component_count; // Number of components in the entity\n uint64_t reserved; // Bytes reserved for future use\n };\n #pragma pack(pop)\n\n #pragma pack(push, 1)\n // Header preceding components\n struct ComponentHeader {\n uint64_t serialized_size; // Size of the serialized component in bytes\n gxf_tid_t tid; // Type ID of the component\n uint64_t name_size; // Size of the component name in bytes\n };\n #pragma pack(pop)\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override { return GXF_SUCCESS; }\n\n gxf_result_t serialize_entity_abi(gxf_uid_t eid, Endpoint* endpoint, uint64_t* size) override;\n gxf_result_t deserialize_entity_abi(gxf_uid_t eid, Endpoint* endpoint) override;\n Expected deserialize_entity_header_abi(Endpoint* endpoint) override;\n\n private:\n // Structure used to organize serializable components\n struct ComponentEntry;\n\n // Populates a list of component entries using a list of component handles\n Expected> createComponentEntries(\n const FixedVector& components);\n // Serializes a list of components and writes them to an endpoint\n // Returns the total number of bytes serialized\n Expected serializeComponents(const FixedVector& entries,\n Endpoint* endpoint);\n // Reads from an endpoint and deserializes a list of components\n Expected deserializeComponents(size_t component_count, Entity entity, Endpoint* endpoint);\n // Searches for a component serializer that supports the given type ID\n // Uses the first valid serializer found and caches it for subsequent lookups\n // Returns an Unexpected if no valid serializer is found\n Expected> findComponentSerializer(gxf_tid_t tid);\n\n Parameter, kMaxComponents>> component_serializers_;\n Parameter verbose_warning_;\n\n // Table that caches type ID with a valid component serializer\n std::unordered_map, TidHash> serializer_cache_;\n // Sequence number for outgoing messages\n uint64_t outgoing_sequence_number_ = 0;\n // Sequence number for incoming messages\n uint64_t incoming_sequence_number_ = 0;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_STD_ENTITY_SERIALIZER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/tests/serialization_tester.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_TESTS_SERIALIZATION_TESTER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_TESTS_SERIALIZATION_TESTER_HPP_\n\n#include \n\n#include \"gxf/serialization/entity_serializer.hpp\"\n#include \"gxf/serialization/serialization_buffer.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\nnamespace test {\n\n// Codelet that serializes incoming messages and stores them in a buffer\n// Messages are immediately deserialized from the buffer and published\nclass SerializationTester : public Codelet {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override { return GXF_SUCCESS; }\n gxf_result_t deinitialize() override { return GXF_SUCCESS; }\n gxf_result_t tick() override;\n\n private:\n Parameter> input_;\n Parameter> output_;\n Parameter> entity_serializer_;\n Parameter> serialization_buffer_;\n};\n\n} // namespace test\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_TESTS_SERIALIZATION_TESTER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/tid_hash.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_TID_HASH_HPP_\n#define NVIDIA_GXF_SERIALIZATION_TID_HASH_HPP_\n\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Hash function for gxf_tid_t that XORs upper 64 bits with lower 64 bits\nstruct TidHash {\n size_t operator()(const gxf_tid_t& tid) const { return tid.hash1 ^ tid.hash2; }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_TID_HASH_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_ALLOCATOR_HPP\n#define NVIDIA_GXF_STD_ALLOCATOR_HPP\n\n#include \n\n#include \"common/byte.hpp\"\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nenum struct MemoryStorageType {\n kHost = 0, // Host Pinned Memory\n kDevice = 1, // Cuda Device Memory\n kSystem = 2, // Heap Memory\n kCudaManaged = 3 // Cuda Managed Memory\n};\n\n// Custom parameter parser for MemoryStorageType\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n const std::string value = node.as();\n if (strcmp(value.c_str(), \"Host\") == 0) {\n return MemoryStorageType::kHost;\n }\n if (strcmp(value.c_str(), \"Device\") == 0) {\n return MemoryStorageType::kDevice;\n }\n if (strcmp(value.c_str(), \"System\") == 0) {\n return MemoryStorageType::kSystem;\n }\n if (strcmp(value.c_str(), \"Managed\") == 0) {\n return MemoryStorageType::kCudaManaged;\n }\n return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};\n }\n};\n\n// Custom parameter parser for MemoryStorageType\ntemplate<>\nstruct ParameterWrapper {\n static Expected Wrap(gxf_context_t context, const MemoryStorageType& value) {\n YAML::Node node(YAML::NodeType::Scalar);\n switch (value) {\n case MemoryStorageType::kHost: {\n node = std::string(\"Host\");\n break;\n }\n case MemoryStorageType::kDevice: {\n node = std::string(\"Device\");\n break;\n }\n case MemoryStorageType::kSystem: {\n node = std::string(\"System\");\n break;\n }\n case MemoryStorageType::kCudaManaged: {\n node = std::string(\"Managed\");\n break;\n }\n default:\n return Unexpected{GXF_PARAMETER_OUT_OF_RANGE};\n }\n return node;\n }\n};\n\n// Lifecycle stages of an allocator\nenum struct AllocatorStage : uint8_t {\n kUninitialized = 0,\n kInitializationInProgress = 1,\n kInitialized = 2,\n kDeinitializationInProgress = 3,\n};\n\n// Provides allocation and deallocation of memory.\nstruct Allocator : public Component {\n virtual ~Allocator() = default;\n\n virtual gxf_result_t is_available_abi(uint64_t size) = 0;\n virtual gxf_result_t allocate_abi(uint64_t size, int32_t type, void** pointer) = 0;\n virtual gxf_result_t free_abi(void* pointer) = 0;\n virtual uint64_t block_size_abi() const;\n\n // Returns true if the allocator can provide a memory block with the given size.\n bool is_available(uint64_t size);\n\n // Allocates a memory block with the given size.\n Expected allocate(uint64_t size, MemoryStorageType type);\n\n // Frees the given memory block.\n Expected free(byte* pointer);\n\n // Get the block size of this allocator, defaults to 1 for byte-based allocators\n uint64_t block_size() const;\n\n // Get the string value of allocator status\n const char* allocator_stage_str(AllocatorStage stage) const;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/async_buffer_receiver.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_ASYNC_BUFFER_RECEIVER_HPP_\n#define NVIDIA_GXF_STD_ASYNC_BUFFER_RECEIVER_HPP_\n\n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/receiver.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief A receiver which uses a Simpson's four-slot buffer to enable lockless/lock-free and\n * asynchronous communication. This receiver is designed to be used in a single producer and single\n * consumer scenario.\n *\n */\nclass AsyncBufferReceiver : public Receiver {\n public:\n gxf_result_t initialize() override;\n\n gxf_result_t deinitialize() override;\n\n gxf_result_t pop_abi(gxf_uid_t* uid) override;\n\n gxf_result_t push_abi(gxf_uid_t other) override;\n\n gxf_result_t peek_abi(gxf_uid_t* uid, int32_t index) override;\n\n gxf_result_t peek_back_abi(gxf_uid_t* uid, int32_t index) override;\n\n size_t capacity_abi() override;\n\n size_t size_abi() override;\n\n gxf_result_t receive_abi(gxf_uid_t* uid) override;\n\n size_t back_size_abi() override;\n\n gxf_result_t sync_abi() override;\n\n gxf_result_t sync_io_abi() override;\n\n private:\n // Resets the four-slot control variables.\n void reset_buffer();\n Entity read_freshest();\n\n // The following variables are used to implement a Simpson's four-slot buffer.\n Entity entity_data_[2][2];\n // Four-slot control variables\n int32_t freshest_;\n int32_t reading_;\n // control bits\n int32_t slots_[2];\n\n // To indicate whether the buffer has been filled at least once. After first-time, receiving end\n // will always be able to retrieve a value from the buffer.\n bool is_filled_first_time_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif /* NVIDIA_GXF_STD_ASYNC_BUFFER_RECEIVER_HPP_ */\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/async_buffer_transmitter.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_ASYNC_BUFFER_TRANSMITTER_HPP_\n#define NVIDIA_GXF_STD_ASYNC_BUFFER_TRANSMITTER_HPP_\n\n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief A transmitter which uses a Simpson's four-slot buffer to enable lockless and asynchronous\n * communication. This transmitter is designed to be used in a single producer and single consumer\n * scenario.\n *\n */\nclass AsyncBufferTransmitter : public Transmitter {\n public:\n gxf_result_t initialize() override;\n\n gxf_result_t pop_abi(gxf_uid_t* uid) override;\n\n gxf_result_t pop_io_abi(gxf_uid_t* uid) override;\n\n gxf_result_t push_abi(gxf_uid_t other) override;\n\n gxf_result_t peek_abi(gxf_uid_t* uid, int32_t index) override;\n\n size_t capacity_abi() override;\n\n size_t size_abi() override;\n\n gxf_result_t publish_abi(gxf_uid_t uid) override;\n\n size_t back_size_abi() override;\n\n gxf_result_t sync_abi() override;\n\n gxf_result_t sync_io_abi() override;\n\n private:\n Entity entity_;\n int size_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif /* NVIDIA_GXF_STD_ASYNC_BUFFER_TRANSMITTER_HPP_ */\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/block_memory_pool.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_BLOCK_MEMORY_POOL_HPP\n#define NVIDIA_GXF_STD_BLOCK_MEMORY_POOL_HPP\n\n#include \n#include \n#include \n#include \n\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/resources.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nclass FixedPoolUint64;\n\n// A memory pools which provides a maximum number of equally sized blocks of\n// memory.\nclass BlockMemoryPool : public Allocator {\n public:\n BlockMemoryPool();\n ~BlockMemoryPool();\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t is_available_abi(uint64_t size) override;\n gxf_result_t allocate_abi(uint64_t size, int32_t type, void** pointer) override;\n gxf_result_t free_abi(void* pointer) override;\n gxf_result_t deinitialize() override;\n uint64_t block_size_abi() const override;\n\n // Returns the storage type of the memory blocks\n MemoryStorageType storage_type() const {\n return static_cast(storage_type_.get());\n }\n\n // Returns the total number of blocks\n uint64_t num_blocks() const {\n return num_blocks_.get();\n }\n\n private:\n Parameter storage_type_;\n Parameter block_size_;\n Parameter num_blocks_;\n Resource> gpu_device_;\n\n void* pointer_;\n std::unique_ptr stack_;\n std::mutex stack_mutex_;\n // Holds lifecycle stage of the allocator\n std::atomic stage_{AllocatorStage::kUninitialized};\n int32_t dev_id_ = -1;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/clock.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_CLOCK_HPP_\n#define NVIDIA_GXF_STD_CLOCK_HPP_\n\n#include \n\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/// @brief Keeps track of time\n//\n// This clock is based on a steady clock however time can be scaled to run slower or faster.\nclass Clock : public Component {\n public:\n virtual ~Clock() = default;\n\n /// @brief The current time of the clock. Time is measured in seconds.\n virtual double time() const = 0;\n\n /// @brief The current timestamp of the clock. Timestamps are measured in nanoseconds.\n virtual int64_t timestamp() const = 0;\n\n /// @brief Waits until the given duration has elapsed on the clock\n virtual Expected sleepFor(int64_t duration_ns) = 0;\n\n /// @brief Waits until the given target time\n virtual Expected sleepUntil(int64_t target_ns) = 0;\n};\n\n/// @brief A clock which runs based on a realtime clock\nclass RealtimeClock : public Clock {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n double time() const override;\n int64_t timestamp() const override;\n Expected sleepFor(int64_t duration_ns) override;\n Expected sleepUntil(int64_t target_time_ns) override;\n\n // Changes time scaling used by the clock.\n Expected setTimeScale(double time_scale);\n\n private:\n Parameter initial_time_offset_;\n Parameter initial_time_scale_;\n Parameter use_time_since_epoch_;\n\n std::chrono::time_point reference_;\n double time_offset_;\n double time_scale_;\n};\n\n/// @brief A clock where time flow is controlled manually\nclass ManualClock : public Clock {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n double time() const override;\n int64_t timestamp() const override;\n Expected sleepFor(int64_t duration_ns) override;\n Expected sleepUntil(int64_t target_time_ns) override;\n\n private:\n Parameter initial_timestamp_;\n\n int64_t current_time_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/codelet.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Codelets are special components which allow the execution of custom code. The user can\n// create her own codelets by deriving from this class and overriding the functions initialize,\n// start, tick, stop, and deinitialize.\nclass Codelet : public Component {\n public:\n virtual ~Codelet() = default;\n\n // This function is called during the start phase of the codelet. It allows derived classes to\n // execute custom code during the start phase. This is a good place to obtain resources which\n // are necessary for ticking the codelet. This function is guaranteed to be called before the\n // first call to tick.\n virtual gxf_result_t start() { return GXF_SUCCESS; }\n\n // This function is called whenever the codelet is expected to do work, e.g. when an event was\n // received or periodically. The tick method can be specified with various other member functions.\n // This function is the main work horse of the codelet.\n virtual gxf_result_t tick() = 0;\n\n // This function is called during the stop phase of the codelet. It allows derived classes to\n // execute custom code during the stop phase. This is a good place to clean up any resources which\n // where obtained during 'start'. After the codelet is stopped it should be in the same state as\n // it was before 'start' was called. Be careful to not leave any unintended left overs as 'start'\n // might be called again afterwards. It is guaranteed that stop is called after the last\n // call to tick. When start was called stop will be called, too.\n virtual gxf_result_t stop() { return GXF_SUCCESS; }\n\n // Timestamp (in nanoseconds) of the beginning of the start, tick or stop function. The execution\n // timestamp does not change during the start, tick or stop function.\n int64_t getExecutionTimestamp() const { return execution_timestamp_; }\n\n // Similar to getExecutionTimestamp but returns time as a floating point number and using seconds\n // as unit. Equivalent to 'ToSeconds(getExecutionCount())'.\n double getExecutionTime() const { return execution_time_; }\n\n // The delta between the current execution time and the execution time of the previous execution.\n // During the start function this will return 0.\n double getDeltaTime() const { return delta_time_; }\n\n // Returns the number of times a codelet is executed. This will return 0 during start and 1 during\n // the first tick.\n int64_t getExecutionCount() const { return execution_count_; }\n\n // Returns true if this is the first time tick is called after start.\n bool isFirstTick() const { return getExecutionCount() == 1; }\n\n private:\n // Class is friend to allow EntityExecutor to call private member functions\n friend class EntityExecutor;\n\n // Called by EntityExecutor before each 'start'\n void beforeStart(int64_t timestamp);\n\n // Called by EntityExecutor before each 'tick'\n void beforeTick(int64_t timestamp);\n\n // Called by EntityExecutor before each 'stop'\n void beforeStop();\n\n // The number of times the codelet tick function was called.\n int64_t execution_count_{0};\n // The timestamp of the previous execution. Equal to 'execution_timestamp' during 'start'.\n int64_t previous_execution_timestamp_{0};\n // The timestamp of the current execution in nanoseconds.\n int64_t execution_timestamp_{0};\n // Same as execution_timestamp_ but in seconds and as a floating point.\n double execution_time_{0.0};\n // The difference between the current and the previous execution time in seconds.\n double delta_time_{0.0};\n};\n\n} // namespace gxf\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/complex.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_COMPLEX_HPP_\n#define NVIDIA_GXF_STD_COMPLEX_HPP_\n\n#include \n#include //NOLINT\n#include //NOLINT\n\nnamespace nvidia {\nnamespace gxf {\n\nusing complex64 = cuda::std::complex;\nusing complex128 = cuda::std::complex;\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/component_allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_COMPONENT_ALLOCATOR_HPP\n#define NVIDIA_GXF_STD_COMPONENT_ALLOCATOR_HPP\n\n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Base class for allocating components.\nclass ComponentAllocator {\n public:\n virtual ~ComponentAllocator() = default;\n\n ComponentAllocator(const ComponentAllocator&) = delete;\n ComponentAllocator(ComponentAllocator&&) = delete;\n ComponentAllocator& operator=(const ComponentAllocator&) = delete;\n ComponentAllocator& operator=(ComponentAllocator&&) = delete;\n\n // Allocates a new component of the specific component type this allocator is handling.\n virtual gxf_result_t allocate_abi(void** out_pointer) = 0;\n\n // Deallocates a component which was previously allocated by this allocator.\n virtual gxf_result_t deallocate_abi(void* pointer) = 0;\n\n Expected allocate();\n\n Expected deallocate(void* pointer);\n\n protected:\n ComponentAllocator() = default;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/component_factory.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_COMPONENT_FACTORY_HPP\n#define NVIDIA_GXF_STD_COMPONENT_FACTORY_HPP\n\n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Base class for extension factories. An extension factory is used to create instances\n// of components.\nclass ComponentFactory {\n public:\n virtual ~ComponentFactory() = default;\n\n ComponentFactory(const ComponentFactory&) = delete;\n ComponentFactory(ComponentFactory&&) = delete;\n ComponentFactory& operator=(const ComponentFactory&) = delete;\n ComponentFactory& operator=(ComponentFactory&&) = delete;\n\n // Allocates a component of the given type\n virtual gxf_result_t allocate_abi(gxf_tid_t tid, void** out_pointer) = 0;\n\n // Frees a component of the given type\n virtual gxf_result_t deallocate_abi(gxf_tid_t tid, void* pointer) = 0;\n\n Expected allocate(gxf_tid_t tid);\n\n Expected deallocate(gxf_tid_t tid, void* pointer);\n\n protected:\n ComponentFactory() = default;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/controller.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_CONTROLLER_HPP_\n#define NVIDIA_GXF_STD_CONTROLLER_HPP_\n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/std/scheduling_condition.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/// @brief The status returned by controller to executor deciding termination\n/// policy\n/// - GXF_EXECUTE_SUCCESS: executor resumes execution\n/// - GXF_EXECUTE_FAILURE_REPEAT: codelet fails and executor repeatedly execute\n/// this entity\n/// - GXF_EXECUTE_FAILURE_DEACTIVATE: codelet fails and executor deactivate this\n/// entity\n/// - GXF_EXECUTE_FAILURE: codelet fails and executor deactivates all the\n/// entities and stops the entire graph\ntypedef enum {\n GXF_EXECUTE_SUCCESS = 0,\n GXF_EXECUTE_FAILURE_REPEAT = 1,\n GXF_EXECUTE_FAILURE_DEACTIVATE = 2,\n GXF_EXECUTE_FAILURE = 3,\n} gxf_execution_status_t;\n\n// Type to represent codelet::tick() result for behavior tree parent and\n// execution status for executor to use termination policy\nstruct gxf_controller_status_t {\n entity_state_t behavior_status;\n gxf_execution_status_t exec_status;\n gxf_controller_status_t(entity_state_t b_status,\n gxf_execution_status_t e_status)\n : behavior_status(b_status), exec_status(e_status) {}\n gxf_controller_status_t() {\n behavior_status = GXF_BEHAVIOR_SUCCESS;\n exec_status = GXF_EXECUTE_SUCCESS;\n }\n};\n\n// Interface for controlling entity's termination policy and entity's execution\n// status\nclass Controller : public Component {\n public:\n virtual ~Controller() = default;\n\n // Return a struct encapsulating the determined behavior status and execution\n // status by the controller given the result of codelet's tick()\n virtual gxf_controller_status_t control(gxf_uid_t eid,\n Expected code) = 0;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_CONTROLLER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/cpu_thread.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_CPU_THREAD_HPP\n#define NVIDIA_GXF_STD_CPU_THREAD_HPP\n\n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Real-time scheduling policies supported by POSIX and Linux kernel\nenum class SchedulingPolicy : int32_t {\n kFirstInFirstOut = 1, // SCHED_FIFO supported by POSIX and Linux kernel\n kRoundRobin = 2, // SCHED_RR supported by POSIX and Linux kernel\n kDeadline = 6 // SCHED_DEADLINE supported by Linux kernel\n};\n\n// Custom parameter parser for SchedulingPolicy\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n const std::string value = node.as();\n if (strcmp(value.c_str(), \"SCHED_FIFO\") == 0) {\n return SchedulingPolicy::kFirstInFirstOut;\n }\n if (strcmp(value.c_str(), \"SCHED_RR\") == 0) {\n return SchedulingPolicy::kRoundRobin;\n }\n if (strcmp(value.c_str(), \"SCHED_DEADLINE\") == 0) {\n return SchedulingPolicy::kDeadline;\n }\n GXF_LOG_ERROR(\"Invalid scheduling policy: %s\", value.c_str());\n return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};\n }\n};\n\n// Custom parameter wrapper for SchedulingPolicy\ntemplate<>\nstruct ParameterWrapper {\n static Expected Wrap(gxf_context_t context, const SchedulingPolicy& value) {\n YAML::Node node(YAML::NodeType::Scalar);\n switch (value) {\n case SchedulingPolicy::kFirstInFirstOut: {\n node = std::string(\"SCHED_FIFO\");\n break;\n }\n case SchedulingPolicy::kRoundRobin: {\n node = std::string(\"SCHED_RR\");\n break;\n }\n case SchedulingPolicy::kDeadline: {\n node = std::string(\"SCHED_DEADLINE\");\n break;\n }\n default:\n GXF_LOG_ERROR(\"Invalid scheduling policy: %d\", static_cast(value));\n return Unexpected{GXF_PARAMETER_OUT_OF_RANGE};\n }\n return node;\n }\n};\n\nclass CPUThread : public Component {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n\n bool pinned() const {\n return pin_entity_;\n }\n\n std::vector pinCores() const {\n const auto maybe_pin_cores = pin_cores_.try_get();\n if (maybe_pin_cores) {\n return maybe_pin_cores.value();\n }\n return {};\n }\n\n Expected schedPolicy() const {\n return sched_policy_.try_get();\n }\n\n Expected schedPriority() const {\n return sched_priority_.try_get();\n }\n\n Expected schedRuntime() const {\n return sched_runtime_.try_get();\n }\n\n Expected schedDeadline() const {\n return sched_deadline_.try_get();\n }\n\n Expected schedPeriod() const {\n return sched_period_.try_get();\n }\n\n // Helper method to check if real-time scheduling is used\n bool isRealtime() const {\n const auto maybe_sched_policy = sched_policy_.try_get();\n if (maybe_sched_policy) {\n auto sched_policy_value = maybe_sched_policy.value();\n return sched_policy_value == SchedulingPolicy::kFirstInFirstOut ||\n sched_policy_value == SchedulingPolicy::kRoundRobin ||\n sched_policy_value == SchedulingPolicy::kDeadline;\n }\n return false;\n }\n\n private:\n // Keep track of whether or not the component should be pinned to a worker thread\n Parameter pin_entity_;\n // CPU core IDs to pin the worker thread to (empty means no core pinning)\n Parameter> pin_cores_;\n\n // Real-time scheduling parameters (optional)\n // Real-time scheduling policy (kFirstInFirstOut, kRoundRobin, kDeadline)\n Parameter sched_policy_;\n // Thread priority (only for kFirstInFirstOut and kRoundRobin)\n Parameter sched_priority_;\n // Expected worst case execution time in nanoseconds (only for kDeadline)\n Parameter sched_runtime_;\n // Relative deadline in nanoseconds (only for kDeadline)\n Parameter sched_deadline_;\n // Period in nanoseconds (only for kDeadline)\n Parameter sched_period_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_CPU_THREAD_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/cuda_green_context.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_CUDA_GREEN_CONTEXT_HPP_\n#define NVIDIA_GXF_STD_CUDA_GREEN_CONTEXT_HPP_\n\n#include \"cuda.h\"\n#include \n\n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/cuda_green_context_pool.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief Holds and provides access to CUgreenCtx. CudaGreenContext is allocated and\n * recycled by CudaGreenContextPool\n */\nclass CudaGreenContext : public Component {\n public:\n CudaGreenContext() = default;\n ~CudaGreenContext();\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n\n // Retrieves CUgreenCtx\n Expected greenContext() const;\n\n // Retrieves CUcontext that associated with this green context\n Expected cudaContext();\n\n uint32_t index() const { return pool_index_; }\n\n CudaGreenContextPool* cudaGreenContextPool() const {\n return cuda_green_context_pool_.try_get().value();\n }\n\n private:\n Parameter index_;\n Parameter> cuda_green_context_pool_;\n Parameter nvtx_identifier_;\n\n CUgreenCtx green_context_ = nullptr;\n CUcontext cuda_context_ = nullptr;\n uint32_t pool_index_ = 0;\n mutable std::shared_timed_mutex mutex_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_CUDA_GREEN_CONTEXT_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/cuda_green_context_pool.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_CUDA_GREEN_CONTEXT_POOL_HPP_\n#define NVIDIA_GXF_STD_CUDA_GREEN_CONTEXT_POOL_HPP_\n\n#include \"cuda.h\"\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/std/resources.hpp\"\n\n#define CHECK_CUDA_ERROR_RESULT(cu_result, fmt, ...) \\\n do { \\\n cudaError_t err = (cu_result); \\\n if (err != cudaSuccess) { \\\n GXF_LOG_ERROR(fmt \", cuda_error: %s, error_str: %s\", ##__VA_ARGS__, \\\n cudaGetErrorName(err), cudaGetErrorString(err)); \\\n return GXF_FAILURE; \\\n } \\\n } while (0)\n\n#define CHECK_CUDA_DRV_ERROR(cu_result, driver_fn_table, fmt, ...) \\\n do { \\\n if (CUDA_SUCCESS != cu_result) { \\\n const char* errorName = nullptr; \\\n const char* errorString = nullptr; \\\n driver_fn_table.cuGetErrorName(cu_result, &errorName); \\\n driver_fn_table.cuGetErrorString(cu_result, &errorString); \\\n GXF_LOG_ERROR(fmt \", cuda driver API failed with error: %s:%s \", \\\n errorName, errorString); \\\n return GXF_FAILURE; \\\n } \\\n } while (0)\n\n#define GET_CUDA_DRV_API_PTR(func, version, name) \\\n do { \\\n cudaDriverEntryPointQueryResult driver_status; \\\n auto result = cudaGetDriverEntryPointByVersion(name, \\\n reinterpret_cast(&func), \\\n version, \\\n cudaEnableDefault, \\\n &driver_status); \\\n if (func == nullptr) { \\\n GXF_LOG_ERROR(\"Failed to load %s from CUDA runtime library, \" \\\n \"error[%d], driver_status: %d\", name, result, driver_status); \\\n return GXF_FAILURE; \\\n } \\\n } while (0)\n\nnamespace nvidia {\nnamespace gxf {\n\nstruct CudaDriverFunctionTable {\n CUresult (*cuDeviceGet)(CUdevice*, int) = nullptr;\n CUresult (*cuGreenCtxGetDevResource)(CUgreenCtx, CUdevResource*, CUdevResourceType) = nullptr;\n CUresult (*cuGreenCtxCreate)(CUgreenCtx*, CUdevResourceDesc, CUdevice, unsigned int) = nullptr;\n CUresult (*cuDevSmResourceSplitByCount)(\n CUdevResource*, unsigned int*, const CUdevResource*, CUdevResource*, unsigned int,\n unsigned int) = nullptr;\n CUresult (*cuCtxFromGreenCtx)(CUcontext*, CUgreenCtx) = nullptr;\n CUresult (*cuDevResourceGenerateDesc)(\n CUdevResourceDesc*, CUdevResource*, unsigned int) = nullptr;\n CUresult (*cuDeviceGetDevResource)(\n CUdevice, CUdevResource*, CUdevResourceType) = nullptr;\n CUresult (*cuGetErrorName)(CUresult, const char**) = nullptr;\n CUresult (*cuGetErrorString)(CUresult, const char**) = nullptr;\n};\n\n/**\n * @brief A pool containing a specified number of CUDA Green Contexts on a single device.\n */\nclass CudaGreenContextPool : public Component {\n public:\n CudaGreenContextPool() = default;\n ~CudaGreenContextPool();\n\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n gxf_result_t registerInterface(Registrar* registrar) override;\n\n Expected getGreenContext(uint32_t index);\n Expected getCudaContext(uint32_t index);\n Expected getPartitionSms(uint32_t index);\n Expected getDefaultContextIndex();\n Expected getDefaultContext();\n Expected getDeviceTotalSms(uint32_t index);\n\n private:\n gxf_result_t reserveGreenContexts(int32_t compute_capability_major);\n gxf_result_t loadCudaDriver();\n\n Resource> gpu_device_;\n Parameter green_context_flags_;\n Parameter num_partitions_;\n Parameter min_sm_count_;\n Parameter> sms_per_partition_;\n Parameter nvtx_identifier_;\n Parameter default_context_;\n\n std::atomic initialized_{false};\n std::mutex mutex_;\n std::vector green_context_;\n std::vector cu_context_;\n uint32_t max_sm_count_ = 0;\n int32_t dev_id_ = -1;\n uint32_t default_index_ = 0;\n\n // Function table for CUDA driver symbols\n CudaDriverFunctionTable cuda_driver_fn_table_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_CUDA_GREEN_CONTEXT_POOL_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/default_extension.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_DEFAULT_EXTENSION_HPP_\n#define NVIDIA_GXF_STD_DEFAULT_EXTENSION_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"common/type_name.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/component_allocator.hpp\"\n#include \"gxf/std/extension.hpp\"\n#include \"gxf/std/new_component_allocator.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nnamespace detail {\n\nstruct VoidBaseHelper {};\n\ntemplate \nstruct BaseTypenameAsString {\n static const char* Value() { return TypenameAsString(); }\n};\n\ntemplate <>\nstruct BaseTypenameAsString {\n static constexpr const char* Value() { return \"\"; }\n};\n\n} // namespace detail\n\n// A standard component factor for GXF extensions. It keeps track of all components in the\n// extensions and provides mechanisms to create components.\nclass DefaultExtension : public Extension {\n public:\n ~DefaultExtension() override = default;\n\n // Sets the extension metadata info\n gxf_result_t setInfo_abi(gxf_tid_t tid, const char* name, const char* desc, const char* author,\n const char* version, const char* license) override;\n\n\n // Capture extension display metadata\n gxf_result_t setDisplayInfo_abi(const char* display_name, const char* category,\n const char* brief) override;\n\n // Gets description of the extension and list of components it provides\n gxf_result_t getInfo_abi(gxf_extension_info_t* info) override;\n\n gxf_result_t checkInfo_abi() override;\n\n // Gets description of specified component (No parameter information)\n gxf_result_t getComponentInfo_abi(const gxf_tid_t tid, gxf_component_info_t* info) override;\n\n gxf_result_t registerComponents_abi(gxf_context_t context) override;\n\n gxf_result_t hasComponent_abi(const gxf_tid_t& tid) override;\n\n gxf_result_t getComponentTypes_abi(gxf_tid_t* pointer, size_t* size) override;\n\n gxf_result_t allocate_abi(gxf_tid_t tid, void** out_pointer) override;\n\n gxf_result_t deallocate_abi(gxf_tid_t tid, void* pointer) override;\n\n gxf_result_t getParameterInfo_abi(gxf_context_t context, const gxf_tid_t cid, const char* key,\n gxf_parameter_info_t* info) override;\n\n gxf_tid_t tid () const { return tid_; }\n\n template \n Expected add(gxf_tid_t tid, const char* description, const char* display_name = \"\",\n const char* brief = \"\") {\n static_assert(std::is_same::value\n || std::is_base_of::value,\n \"The given base class is not actually a base class\");\n static_assert(!std::is_base_of::value ||\n (std::is_base_of::value || std::is_same::value),\n \"If a component derives from Codelet then its base class also needs to derive \"\n \"from Codelet. Have you used Component as base class instead of Codelet?\");\n\n if (find(tid)) {\n return Unexpected{GXF_FACTORY_DUPLICATE_TID};\n }\n\n std::string display_name_str{display_name};\n if (display_name_str.length() > 50) {\n GXF_LOG_ERROR(\"Component display name '%s' exceeds 50 characters\", display_name);\n return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};\n }\n\n std::string brief_str{brief};\n if (brief_str.length() > 128) {\n GXF_LOG_ERROR(\"Component brief '%s' exceeds 128 characters\", brief);\n return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};\n }\n\n std::string description_str{description};\n if (description_str.length() > 1026) {\n GXF_LOG_ERROR(\"Component description '%s' exceeds 1026 characters\", description);\n return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};\n }\n\n auto result = entries_.push_back({\n tid, TypenameAsString(), detail::BaseTypenameAsString::Value(),\n description_str, display_name_str, brief_str,\n std::is_abstract::value ? nullptr : std::make_unique>()});\n if (!result) {\n GXF_LOG_WARNING(\"Exceeding maximum number of components\");\n return Unexpected{GXF_EXCEEDING_PREALLOCATED_SIZE};\n }\n return Success;\n }\n\n private:\n struct Entry {\n gxf_tid_t tid;\n std::string name;\n std::string base;\n std::string description;\n std::string display_name;\n std::string brief;\n std::unique_ptr allocator;\n };\n\n Expected find(const gxf_tid_t& tid);\n\n FixedVector entries_;\n gxf_tid_t tid_{GxfTidNull()};\n std::string name_;\n std::string description_;\n std::string author_;\n std::string extension_version_;\n std::string gxf_core_version_{kGxfCoreVersion}; // FIXME: Use setInfo() api to set this post 2.3\n std::string license_;\n std::string display_name_;\n std::string category_;\n std::string brief_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_DEFAULT_EXTENSION_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/dlpack_utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"dlpack/dlpack.h\"\n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Determine the GPU device (if any) associated with a raw pointer\nExpected DLDeviceFromPointer(void* ptr);\n\n/**\n * @brief Fill strides from the given DLTensor object.\n *\n * The following fields are used to fill strides:\n *\n * - ndim\n * - shape\n * - dtype\n *\n * If tensor's strides is nullptr, `strides` argument is filled with the calculated strides of the\n * given DLTensor object. Otherwise, `strides` argument is filled with the given DLTensor object's\n * strides. `strides` vector would be resized to the size of `ndim` field of the given DLTensor\n * object.\n *\n * @param tensor DLTensor object that holds information to fill strides.\n * @param[out] strides Strides to fill.\n * @param to_num_elments If true, the strides in `strides` argument are in number of elements, not\n * bytes (default: false).\n */\nvoid ComputeDLPackStrides(const DLTensor& tensor, std::vector& strides,\n bool to_num_elements = false);\n\n// Return DLDataType object from a NumPy type string.\nExpected DLDataTypeFromTypeString(const std::string& typestr);\n\n/**\n * @brief Return a string providing the basic type of the homogeneous array in NumPy.\n *\n * Note: This method assumes little-endian for now.\n *\n * @return A const character pointer that represents a string\n */\nExpected numpyTypestr(const DLDataType dtype);\n} // namespace gxf\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/double_buffer_receiver.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef DOUBLE_BUFFER_RECEIVER_HPP\n#define DOUBLE_BUFFER_RECEIVER_HPP\n\n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/gems/staging_queue/staging_queue.hpp\"\n#include \"gxf/std/receiver.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A receiver which uses a double-buffered queue where new messages are first pushed to a\n// backstage. Incoming messages are not immediately available and need to be moved to the mainstage\n// first.\nclass DoubleBufferReceiver : public Receiver {\n public:\n using queue_t = ::gxf::staging_queue::StagingQueue;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n\n gxf_result_t initialize() override;\n\n gxf_result_t deinitialize() override;\n\n gxf_result_t pop_abi(gxf_uid_t* uid) override;\n\n gxf_result_t push_abi(gxf_uid_t other) override;\n\n gxf_result_t peek_abi(gxf_uid_t* uid, int32_t index) override;\n\n gxf_result_t peek_back_abi(gxf_uid_t* uid, int32_t index) override;\n\n size_t capacity_abi() override;\n\n size_t size_abi() override;\n\n gxf_result_t receive_abi(gxf_uid_t* uid) override;\n\n size_t back_size_abi() override;\n\n gxf_result_t sync_abi() override;\n\n gxf_result_t sync_io_abi() override;\n\n Parameter capacity_;\n Parameter policy_;\n\n private:\n std::unique_ptr queue_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/double_buffer_transmitter.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef DOUBLE_BUFFER_TRANSMITTER_HPP\n#define DOUBLE_BUFFER_TRANSMITTER_HPP\n\n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/gems/staging_queue/staging_queue.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A transmitter which uses a double-buffered queue where messages are pushed to a backstage after\n// they are published. Outgoing messages are not immediately available and need to be\n// moved to the backstage first.\nclass DoubleBufferTransmitter : public Transmitter {\n public:\n using queue_t = ::gxf::staging_queue::StagingQueue;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n\n gxf_result_t initialize() override;\n\n gxf_result_t deinitialize() override;\n\n gxf_result_t pop_abi(gxf_uid_t* uid) override;\n\n gxf_result_t pop_io_abi(gxf_uid_t* uid) override;\n\n gxf_result_t push_abi(gxf_uid_t other) override;\n\n gxf_result_t peek_abi(gxf_uid_t* uid, int32_t index) override;\n\n size_t capacity_abi() override;\n\n size_t size_abi() override;\n\n gxf_result_t publish_abi(gxf_uid_t uid) override;\n\n size_t back_size_abi() override;\n\n gxf_result_t sync_abi() override;\n\n gxf_result_t sync_io_abi() override;\n\n Parameter capacity_;\n Parameter policy_;\n\n private:\n std::unique_ptr queue_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/eos.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef EOS_HPP\n#define EOS_HPP\n\n#include \n\n#include \"gxf/core/entity.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A component which represents an end-of-stream notification\nclass EndOfStream {\n public:\n // Returns the stream which generated the notification. Negative value indicates\n // pipeline/graph EoS. Non-negative value indicates individual stream EoS\n int64_t stream_id() { return stream_id_; }\n\n void stream_id(int64_t stream_id) { stream_id_ = stream_id; }\n\n EndOfStream() = default;\n\n ~EndOfStream() = default;\n\n EndOfStream(const EndOfStream&) = delete;\n\n EndOfStream(EndOfStream&& other) { *this = std::move(other); }\n\n EndOfStream& operator=(const EndOfStream&) = delete;\n\n EndOfStream& operator=(EndOfStream&& other) {\n stream_id_ = other.stream_id_;\n return *this;\n }\n\n // Factory method to create EOS message entity\n static Expected createEoSMessage(gxf_context_t context, int64_t stream_id = -1) {\n Expected message = Entity::New(context);\n if (!message) { return message; }\n\n auto eos = message.value().add();\n if (!eos) { return ForwardError(eos); }\n eos.value()->stream_id_ = stream_id;\n\n return message;\n }\n\n private:\n int64_t stream_id_ = -1;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/event_based_scheduler.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_EVENT_BASED_SCHEDULER_HPP_\n#define NVIDIA_GXF_STD_EVENT_BASED_SCHEDULER_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include // NOLINT\n#include \n#include \n#include \n#include \n#include \n\n#include \"cuda.h\"\n\n#include \"common/fixed_map.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/clock.hpp\"\n#include \"gxf/std/cpu_thread.hpp\"\n#include \"gxf/std/cuda_green_context_pool.hpp\"\n#include \"gxf/std/gems/event_list/unique_event_list.hpp\"\n#include \"gxf/std/gems/staging_queue/staging_queue.hpp\"\n#include \"gxf/std/gems/timed_job_list/timed_job_list.hpp\"\n#include \"gxf/std/resources.hpp\"\n#include \"gxf/std/scheduler.hpp\"\n#include \"gxf/std/scheduling_condition.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Forward declarations\nclass EntityExecutor;\n\n/// @brief Event based scheduler\n///\n/// The scheduler requires a Clock to keep track of time. It spawns a dispatcher thread and several\n/// worker threads as configured. Dispatcher thread checks condition of entities and place them in\n/// worker queue if they are ready to run or have expected time to run.\nclass EventBasedScheduler : public Scheduler {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n gxf_result_t prepare_abi(EntityExecutor* executor) override;\n gxf_result_t schedule_abi(gxf_uid_t eid) override;\n gxf_result_t unschedule_abi(gxf_uid_t eid) override;\n gxf_result_t runAsync_abi() override;\n gxf_result_t stop_abi() override;\n gxf_result_t wait_abi() override;\n gxf_result_t event_notify_abi(gxf_uid_t eid, gxf_event_t event) override;\n gxf_result_t notifyDispatcher(gxf_uid_t eid = kNullUid);\n\n private:\n // Enum to indicate if a worker thread has acquired an entity for execution or not\n enum class EntityOwnership : uint8_t {\n kFree = 0,\n kAcquired\n };\n\n class ScheduleEntity {\n public:\n ScheduleEntity(gxf_uid_t eid, const char * name) {\n eid_ = eid;\n name_ = std::string(name);\n condition_ = SchedulingCondition{SchedulingConditionType::READY, 0};\n ownership_ = EntityOwnership::kFree;\n queue_index_ = -1;\n thread_pool_id_ = -1;\n thread_id_ = kDefaultThreadPoolThreadId;\n unschedule_ = false;\n is_present_in_ready_queue_ = false;\n cuda_context_ = nullptr;\n cuda_green_context_pool_ = nullptr;\n }\n\n void updateCondition() {\n condition_ = SchedulingCondition{SchedulingConditionType::READY, 0};\n }\n\n Expected tryToAcquire(void) {\n EntityOwnership free = EntityOwnership::kFree;\n if (ownership_.compare_exchange_strong(free, EntityOwnership::kAcquired)) {\n return Success;\n }\n return Unexpected{GXF_FAILURE};\n }\n\n Expected releaseOwnership(void) {\n EntityOwnership acquired = EntityOwnership::kAcquired;\n if (ownership_.compare_exchange_strong(acquired, EntityOwnership::kFree)) {\n return Success;\n }\n return Unexpected{GXF_FAILURE};\n }\n\n int32_t queue_index_;\n gxf_uid_t eid_;\n SchedulingCondition condition_;\n std::string name_;\n std::atomic ownership_;\n int32_t thread_pool_id_;\n gxf_uid_t thread_id_;\n bool unschedule_;\n std::shared_timed_mutex ready_queue_sync_mutex_;\n bool is_present_in_ready_queue_;\n CUcontext cuda_context_ = nullptr;\n CudaGreenContextPool* cuda_green_context_pool_ = nullptr;\n };\n\n std::unordered_map> entities_;\n\n struct TimeStat {\n std::atomic execTime = {0};\n std::atomic waitTime = {0};\n std::atomic execCount = {0};\n };\n\n struct TimeStat dispatcherStats;\n struct TimeStat workerStats; // operations from multiple worker threads\n\n static constexpr int64_t kMsToNs = 1'000'000l; // Convenient constant of 1 ms = 1e6 ns\n static constexpr int64_t kMaxSlipNs = 1 * kMsToNs; // Max slip tolerance set to 1 ms\n static constexpr size_t kMaxThreads = 128; // Max number of worker threads\n\n // Common thread id for all the worker threads in default thread pool\n static constexpr int64_t kDefaultThreadPoolThreadId = -1;\n // Position of ready queue for threads belonging to default thread pool\n static constexpr int64_t kDefaultThreadPoolQueueIndex = 0;\n // Entrance for dispatcher threads\n void dispatcherThreadEntrance();\n // notify the dispatcher thread\n // Move entity to some queue\n void dispatchEntity(std::shared_ptr e);\n void dispatchEntityAsync(std::shared_ptr e);\n // Entrance for async event handler thread\n void asyncEventThreadEntrance();\n // Entrance for worker threads\n void workerThreadEntrance(ThreadPool* pool, int64_t thread_number,\n gxf_uid_t cpu_thread_cid = kUnspecifiedUid);\n\n // Checks if need to stop due to no active entities or expiration\n bool checkEndingCriteria(int64_t timestamp);\n\n // Updates condition of specific entity id and keep track of how many entities are good to run\n void updateCondition(std::shared_ptr e,\n const SchedulingCondition& next_condition);\n\n // stops all async threads and deactivates all the entities\n gxf_result_t stopAllThreads();\n\n // stops all jobs queued in dispatcher and workers\n void stopAllJobs();\n\n // returns the current state of the scheduler as string\n const char* schedulerStateString();\n // cache thread info for pinned job into resources_ and set cuda context if provided\n gxf_result_t prepareResourceMapStrict(std::shared_ptr e);\n // index of the ready queue in the ready_wait_time_jobs_ vector where entity is supposed to go\n\n uint64_t getReadyCount();\n\n // Helper functions for configuring worker threads\n gxf_result_t configureThread(gxf_uid_t thread_uid, gxf_uid_t cpu_thread_cid);\n gxf_result_t setCPUAffinity(const std::vector& cpu_cores);\n bool isRealtimeCPUThread(gxf_uid_t cpu_thread_cid);\n\n // Load CUDA Driver API functions through runtime API\n gxf_result_t loadDriverFunctions();\n\n // Parameters\n Parameter> clock_;\n Parameter max_duration_ms_;\n Parameter stop_on_deadlock_;\n Parameter stop_on_deadlock_timeout_;\n Parameter worker_thread_number_;\n Parameter thread_pool_allocation_auto_;\n Parameter worker_thread_name_id_;\n // CPU core IDs to pin the worker threads to (empty means no core pinning)\n Parameter> pin_cores_;\n\n EntityExecutor* executor_ = nullptr;\n\n Entity default_thread_pool_entity_;\n ThreadPool* default_thread_pool_;\n\n // thread pool set including default pool and added pools\n std::set thread_pool_set_;\n\n // map for storing the relevant ready_wait_queue\n FixedMap thread_queue_mapping_;\n\n gxf_result_t thread_error_code_;\n\n // A thread to dispatch jobs to worker pool\n std::thread dispatcher_thread_;\n\n // A thread to trigger exit after max time duration\n std::thread max_duration_thread_;\n\n // Mutex to synchronize dispatcher thread\n std::mutex dispatcher_sync_mutex_;\n\n // Mutex to synchronize max duration thread\n std::mutex max_duration_sync_mutex_;\n\n // instances of dispatcher/worker threads. 0 index would be async event handler thread.\n std::vector async_threads_;\n\n // Keep track of the timestamp that the scheduler started working for checking expiration\n int64_t start_timestamp_ = 0;\n\n // Queue with execution time for jobs to execute\n std::vector>> ready_wait_time_jobs_;\n\n // synchronize entities\n std::mutex external_event_notification_mutex_;\n std::mutex internal_event_notification_mutex_;\n\n // Mutex to synchronize worker thread pool\n std::mutex thread_sync_mutex_;\n std::condition_variable thread_sync_cv_;\n\n // Keep track of asynchronous external events\n std::unique_ptr> external_event_notified_;\n // Holds entities waiting for some event\n std::unique_ptr> event_waiting_;\n // Holds entities waiting for custom conditions\n std::unique_ptr> waiting_;\n\n // Keep track of asynchronous internal events\n std::unique_ptr> internal_event_notified_;\n\n // Running count of entities in flight / execution\n std::atomic running_threads_{0};\n\n std::condition_variable external_event_notification_cv_;\n std::condition_variable internal_event_notification_cv_;\n\n std::condition_variable max_duration_thread_cv_;\n\n // enum type to represent scheduler state changes\n enum class State : uint8_t {\n kNotStarted = 0, // Scheduler has not started execution yet, starts during runAsync_abi()\n kRunning, // Execution threads are running\n kStopping, // Ending criteria reached, execution threads are doing pending jobs\n kStopped, // Scheduler has stopped\n };\n\n std::atomic state_{State::kNotStarted};\n std::mutex state_change_mutex_;\n std::condition_variable work_done_cv_;\n\n // latest timestamp from last should_stop == false\n int64_t last_no_stop_ts_ = 0;\n // maintain last no stop timestamp, and check if need to update should_stop\n gxf_result_t stop_on_deadlock_timeout(const int64_t timeout,\n const int64_t now, bool& should_stop);\n\n // Deadlock detection grace period end timestamp\n int64_t grace_end_timestamp_ = 0;\n // Armed flag to require two consecutive deadlock checks before exiting\n bool deadlock_armed_ = false;\n\n // CUDA Driver API\n CUresult (*fnCuCtxPushCurrent)(CUcontext) = nullptr;\n CUresult (*fnCuCtxPopCurrent)(CUcontext*) = nullptr;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_EVENT_BASED_SCHEDULER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/extension.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_EXTENSION_HPP\n#define NVIDIA_GXF_STD_EXTENSION_HPP\n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/std/component_factory.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Interface used for extensions. An extension class is holding information about the extension\n// and allows creation of components which are provided by the extension.\nclass Extension : public ComponentFactory {\n public:\n virtual ~Extension() = default;\n\n Extension(const Extension&) = delete;\n Extension(Extension&&) = delete;\n Extension& operator=(const Extension&) = delete;\n Extension& operator=(Extension&&) = delete;\n\n // Capture extension metadata\n virtual gxf_result_t setInfo_abi(gxf_tid_t tid, const char* name, const char* desc,\n const char* author, const char* version,\n const char* license) = 0;\n\n // Capture extension display metadata\n virtual gxf_result_t setDisplayInfo_abi(const char* display_name, const char* category,\n const char* brief) = 0;\n\n // Check if extension metadata has been captured\n virtual gxf_result_t checkInfo_abi() = 0;\n\n // Gets description of the extension and list of components it provides\n virtual gxf_result_t getInfo_abi(gxf_extension_info_t* info) = 0;\n\n // Registers all components in the extension with the given context.\n virtual gxf_result_t registerComponents_abi(gxf_context_t context) = 0;\n\n // Checks if a component is present in the extension or not\n virtual gxf_result_t hasComponent_abi(const gxf_tid_t& tid) = 0;\n\n // Gets a list with IDs of all types which are registered with this factory.\n virtual gxf_result_t getComponentTypes_abi(gxf_tid_t* pointer, size_t* size) = 0;\n\n // Gets description of specified component (No parameter information)\n virtual gxf_result_t getComponentInfo_abi(const gxf_tid_t tid, gxf_component_info_t* info) = 0;\n\n // Gets description of specified parameter\n virtual gxf_result_t getParameterInfo_abi(gxf_context_t context, const gxf_tid_t cid,\n const char* key, gxf_parameter_info_t* info) = 0;\n\n Expected registerComponents(gxf_context_t context);\n Expected hasComponent(const gxf_tid_t& tid);\n Expected getComponentTypes(gxf_tid_t* pointer, size_t* size);\n Expected setInfo(gxf_tid_t tid, const char* name, const char* desc,\n const char* author, const char* version, const char* license);\n Expected setDisplayInfo(const char* display_name, const char* category, const char* brief);\n Expected checkInfo();\n Expected getInfo(gxf_extension_info_t* info);\n Expected getComponentInfo(const gxf_tid_t tid, gxf_component_info_t* info);\n Expected getParameterInfo(gxf_context_t context, const gxf_tid_t cid, const char* key,\n gxf_parameter_info_t* info);\n\n protected:\n Extension() = default;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/extension_factory_helper.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_FACTORY_HPP\n#define NVIDIA_GXF_CORE_FACTORY_HPP\n\n#include \n#include \n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/std/default_extension.hpp\"\n\n// Helper macro to create an extensions factory. Every component in this extensions must be\n// explicitly registered. Otherwise it can not be used by GXF applications.\n//\n// A component can be registered using the macro GXF_EXT_FACTORY_ADD. For each\n// component the base class need to be specified. Components base classes must be registered before\n// they can be used as a base class in a component registration. If a component does not have a base\n// class the macro GXF_EXT_FACTORY_ADD_0 is used instead.\n//\n// Components can have at most one base class. Multiple base classes are not supported.\n//\n// Every component must be registered with a unique 128-bit identifier. The identifier must be\n// unique across all existing extensions.\n//\n// Note that the extension factory can also be created manually without using these macros.\n//\n// Usage example:\n// GXF_EXT_FACTORY_BEGIN(0x8ec2d5d6b5df48bf, 0x8dee0252606fdd7e, \"1.0.0\")\n// GXF_EXT_FACTORY_SET_INFO(\"Extension Name\", \"Extension Desc\", \"Author\", \"LICENSE\")\n// GXF_EXT_FACTORY_ADD(0x792151bf31384603, 0xa9125ca91828dea8,\n// nvidia::gxf::Queue, nvidia::gxf::Component,\n// \"Interface for storing entities in a queue\");\n// GXF_EXT_FACTORY_ADD(0xc30cc60f0db2409d, 0x92b6b2db92e02cce,\n// nvidia::gxf::Transmitter, nvidia::gxf::Queue,\n// \"Interface for publishing entities\");\n// ...\n// GXF_EXT_FACTORY_END()\n#define GXF_EXT_FACTORY_BEGIN() \\\n namespace { \\\n nvidia::gxf::Expected> \\\n CreateComponentFactory() { \\\n auto factory = std::make_unique(); \\\n if (!factory) { return nvidia::gxf::Unexpected{GXF_OUT_OF_MEMORY}; } \\\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_SET_INFO(H1, H2, NAME, DESC, AUTHOR, VERSION, LICENSE) \\\n { \\\n const nvidia::gxf::Expected result = factory->setInfo({(H1), (H2)}, NAME, DESC, \\\n AUTHOR, VERSION, LICENSE); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n } \\\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_SET_DISPLAY_INFO(DISPLAY_NAME, CATEGORY, BRIEF) \\\n { \\\n const nvidia::gxf::Expected result = factory->setDisplayInfo(DISPLAY_NAME, CATEGORY, \\\n BRIEF); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n }\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_ADD_0(H1, H2, TYPE, DESC) \\\n { \\\n const nvidia::gxf::Expected result = factory->add({(H1), (H2)}, DESC); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n } \\\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_ADD_0_VERBOSE(H1, H2, TYPE, DISPLAY_NAME, BRIEF, DESC) \\\n { \\\n const nvidia::gxf::Expected result = factory->add({(H1), (H2)}, DESC, \\\n DISPLAY_NAME, BRIEF); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n }\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_ADD_0_LITE(H1, H2, TYPE) \\\n { \\\n const nvidia::gxf::Expected result = factory->add({(H1), (H2)}, \"\"); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n } \\\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_ADD(H1, H2, TYPE, BASE, DESC) \\\n { \\\n const nvidia::gxf::Expected result = factory->add({(H1), (H2)}, DESC); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n } \\\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_ADD_VERBOSE(H1, H2, TYPE, BASE, DISPLAY_NAME, BRIEF, DESC) \\\n { \\\n const nvidia::gxf::Expected result = factory->add({(H1), (H2)}, DESC, \\\n DISPLAY_NAME, BRIEF); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n }\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_ADD_LITE(H1, H2, TYPE, BASE) \\\n { \\\n const nvidia::gxf::Expected result = factory->add({(H1), (H2)}, \"\"); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n } \\\n\n// See GXF_EXT_FACTORY_BEGIN for more information.\n#define GXF_EXT_FACTORY_END() \\\n const nvidia::gxf::Expected result = factory->checkInfo(); \\\n if (!result) { return nvidia::gxf::ForwardError(result); } \\\n return std::move(factory); \\\n } \\\n } /* namespace */ \\\n \\\n extern \"C\" { \\\n gxf_result_t GxfExtensionFactory(void** result) { \\\n static nvidia::gxf::Expected> s_factory \\\n = CreateComponentFactory(); \\\n if (!s_factory) { return s_factory.error(); } \\\n *result = s_factory.value().get(); \\\n return GXF_SUCCESS; \\\n } \\\n } /* extern \"C\" */ \\\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/event_list/event_list.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_EVENT_LIST_HPP_\n#define NVIDIA_GXF_EVENT_LIST_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A simple thread safe list implementation to store and retrieve events\ntemplate \nclass EventList {\n public:\n EventList() = default;\n EventList(const EventList&) = delete;\n EventList& operator=(const EventList&) = delete;\n\n // Adds an item on to the event list\n void pushEvent(T item) {\n std::lock_guard lock(list_mutex_);\n list_.push_back(item);\n }\n\n // Removes an event from the list if it exists and returns true,\n // returns false otherwise\n void removeEvent(T item) {\n std::lock_guard lock(list_mutex_);\n\n for (auto it = list_.begin(); it != list_.end();) {\n if (*it == item) {\n // remove all instances in case of multiple event notifications\n // for the same entity\n it = list_.erase(it);\n } else {\n ++it;\n }\n }\n }\n\n // pops the first element in the list\n Expected popEvent() {\n std::lock_guard lock(list_mutex_);\n if (list_.empty()) { return Unexpected{GXF_FAILURE}; }\n\n T event = list_.front();\n list_.pop_front();\n return event;\n }\n\n // exports a copy of the events in the list\n std::list exportList() const {\n std::lock_guard lock(list_mutex_);\n return list_;\n }\n\n // checks if the list is empty\n bool empty() const {\n std::lock_guard lock(list_mutex_);\n return list_.empty();\n }\n\n // returns size of the event list\n size_t size() const {\n std::lock_guard lock(list_mutex_);\n return list_.size();\n }\n\n // checks if the list has event\n bool hasEvent(T item) const {\n std::lock_guard lock(list_mutex_);\n for (const auto& element : list_) {\n if (item == element) { return true; }\n }\n return false;\n }\n\n // clears the event list\n void clear() {\n std::lock_guard lock(list_mutex_);\n list_.clear();\n }\n\n mutable std::mutex list_mutex_;\n std::list list_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_EVENT_LIST_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/event_list/unique_event_list.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_UNIQUE_EVENT_LIST_HPP_\n#define NVIDIA_GXF_UNIQUE_EVENT_LIST_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A simple thread safe list implementation to store and retrieve events\ntemplate \nclass UniqueEventList {\n public:\n UniqueEventList() = default;\n UniqueEventList(const UniqueEventList&) = delete;\n UniqueEventList& operator=(const UniqueEventList&) = delete;\n\n // Adds an item on to the event list\n bool pushEvent(T item) {\n std::lock_guard lock(list_mutex_);\n if (items_.find(item) != items_.end()) { return false; }\n list_.push_back(item);\n items_.insert(std::make_pair(item, --list_.end()));\n return true;\n }\n\n // Removes an event from the list if it exists and returns true,\n // returns false otherwise\n void removeEvent(T item) {\n std::lock_guard lock(list_mutex_);\n\n if (items_.find(item) == items_.end()) { return; }\n list_.erase(items_.at(item));\n items_.erase(item);\n }\n\n // pops the first element in the list\n Expected popEvent() {\n std::lock_guard lock(list_mutex_);\n if (list_.empty()) { return Unexpected{GXF_FAILURE}; }\n\n T event = list_.front();\n list_.pop_front();\n items_.erase(event);\n return event;\n }\n\n // exports a copy of the events in the list\n std::list exportList() const {\n std::lock_guard lock(list_mutex_);\n return list_;\n }\n\n // checks if the list is empty\n bool empty() const {\n std::lock_guard lock(list_mutex_);\n return list_.empty();\n }\n\n // returns size of the event list\n size_t size() const {\n std::lock_guard lock(list_mutex_);\n return items_.size();\n }\n\n // checks if the list has event\n bool hasEvent(T item) const {\n std::lock_guard lock(list_mutex_);\n return items_.find(item) != items_.end() ? true : false;\n }\n\n // clears the event list\n void clear() {\n std::lock_guard lock(list_mutex_);\n list_.clear();\n items_.clear();\n }\n\n mutable std::mutex list_mutex_;\n std::list list_;\n std::unordered_map::iterator> items_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_UNIQUE_EVENT_LIST_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/queue_thread/queue_thread.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_GEMS_QUEUE_THREAD_HPP\n#define NVIDIA_GXF_STD_GEMS_QUEUE_THREAD_HPP\n\n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"common/logger.hpp\"\n\n#define STR(str) ((str).empty() ? \"DefaultName\" : (str).c_str())\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * Entry wrapper for the user item and its associated promise\n*/\ntemplate \nstruct UserItemWithPromise {\n // typedef ItemType user_item_type;\n ItemType user_item;\n std::promise promise;\n bool is_stop_signal = false;\n\n UserItemWithPromise(ItemType i) : user_item(std::move(i)) {}\n UserItemWithPromise() : is_stop_signal(true) {}\n};\n\n/**\n * A thread safe generic container serving as the queue for QueueThread\n*/\ntemplate \nclass GuardQueue {\n public:\nusing Entry = UserItemWithPromise;\n void push(Entry data) {\n std::unique_lock lock(queue_mutex_);\n queue_.emplace_back(std::move(data));\n queue_cv_.notify_one();\n }\n Entry pop() {\n GXF_LOG_VERBOSE(\"GuardQueue::pop() acquiring lock...\");\n std::unique_lock lock(queue_mutex_);\n GXF_LOG_VERBOSE(\"GuardQueue::pop() acquired lock, waiting on cv...\");\n queue_cv_.wait(\n lock, [this]() {\n bool wait_condition = wakeup_once_ || !queue_.empty();\n GXF_LOG_VERBOSE(\"GuardQueue::pop() cv wait condition[%d]\", wait_condition);\n return wait_condition; });\n if (wakeup_once_) {\n wakeup_once_ = false;\n GXF_LOG_VERBOSE(\"GuardQueue pop end on wakeup signal\");\n // empty Entry carries is_stop_signal true\n return Entry();\n }\n GXF_ASSERT_TRUE(!queue_.empty());\n Entry ret = std::move(*queue_.begin());\n queue_.erase(queue_.begin());\n GXF_LOG_VERBOSE(\"GuardQueue::pop() popped an entry\");\n return ret;\n }\n void wakeupOnce() {\n GXF_LOG_VERBOSE(\"GuardQueue trigger wakeup once\");\n std::unique_lock lock(queue_mutex_);\n wakeup_once_ = true;\n queue_cv_.notify_all();\n GXF_LOG_VERBOSE(\"GuardQueue finish wakeup once notification\");\n }\n void clear() {\n GXF_LOG_VERBOSE(\"GuardQueue clear\");\n std::unique_lock lock(queue_mutex_);\n queue_.clear();\n wakeup_once_ = false;\n }\n int size() {\n std::unique_lock lock(queue_mutex_);\n return queue_.size();\n }\n\n private:\n std::mutex queue_mutex_;\n std::condition_variable queue_cv_;\n std::list queue_;\n bool wakeup_once_ = false;\n};\n\n/**\n * The Async Runnable\n * Usage is similar to std::thread, but here the run function is event-driven callback.\n *\n * Construction:\n * 1. user event type in template;\n * 2. user run function implementation that takes user event type;\n * 3. thread name.\n *\n * Upon startup or no event is enqueued, the process thread remains sleep.\n * Whenever an event is raised in caller thread, simply enqueue that event\n * then the run function callback will process the event asynchronously\n *\n * Optionally an std::future is returned for each enqueued event, such that\n * users can synchronize completion of the event.\n*/\ntemplate \nclass QueueThread {\n public:\n using Entry = UserItemWithPromise;\n using RunFunction = std::function;\n\n /**\n * Constructor, asynchronously running RunFunction\n */\n QueueThread(RunFunction run_function, const std::string& name)\n : run_function_(run_function) {\n std::promise promise;\n std::future future = promise.get_future();\n GXF_LOG_DEBUG(\"QueueThread starting new thread\");\n thread_ = std::thread([&promise, this]() {\n GXF_LOG_DEBUG(\"QueueThread std::thread created[name: %s, ID: %s]\",\n this->name_.c_str(), callerThreadId().c_str());\n promise.set_value();\n this->threadLoop();\n });\n setThreadName(name);\n future.wait();\n }\n\n /**\n * set thread name for profiling display\n */\n void setThreadName(const std::string& name) {\n GXF_ASSERT_TRUE(!name.empty());\n name_ = name;\n // POSIX pthread_setname_np max length limit 15 characters plus null terminator\n std::string pthread_name = (name.length() > 15) ? name.substr(0, 15) : name;\n if (thread_.joinable()) {\n if (pthread_setname_np(thread_.native_handle(), pthread_name.c_str()) != 0) {\n GXF_LOG_ERROR(\"set thread name: %s failed\", STR(pthread_name));\n return;\n }\n GXF_LOG_DEBUG(\"QueueThread set new thread name: %s\", STR(pthread_name));\n }\n }\n\n /**\n * Destructor\n */\n ~QueueThread() {\n if (!joined_) {\n // Ensure the stop logic is called if not already done so\n stop();\n }\n // Clear any remaining items after the thread has been joined\n guard_queue_.clear();\n }\n\n /**\n * Main API. Enqueue item to process, return future to sync the result.\n */\n std::future queueItem(ItemType item) {\n Entry itemWithPromise(std::move(item));\n std::future future = itemWithPromise.promise.get_future();\n guard_queue_.push(std::move(itemWithPromise));\n\n return future;\n }\n\n /**\n * Thread safe size check\n */\n int size() {\n return guard_queue_.size();\n }\n\n /**\n * Stop the Async Runnable\n */\n void stop() {\n std::string caller_thread_id = callerThreadId();\n GXF_LOG_DEBUG(\"QueueThread[%s]::stop() caller thread[%s] acquiring stop lock...\",\n name_.c_str(), caller_thread_id.c_str());\n {\n std::lock_guard lock(stop_mutex_);\n stop_requested_ = true;\n }\n GXF_LOG_DEBUG(\"QueueThread[%s]::stop() caller thread[%s] acquired stop lock\",\n name_.c_str(), caller_thread_id.c_str());\n // Wake up the thread if it's waiting for new items\n guard_queue_.wakeupOnce();\n // Notify the wait() that stop was requested\n stop_cv_.notify_all();\n // Try join the thread, thread safe\n joinThread();\n }\n\n /**\n * Wait the Async Runnable\n */\n void wait() {\n std::string caller_thread_id = callerThreadId();\n GXF_LOG_DEBUG(\"QueueThread[%s]::wait() caller thread[%s] acquiring stop lock...\",\n name_.c_str(), caller_thread_id.c_str());\n\n std::unique_lock lock(stop_mutex_);\n\n GXF_LOG_DEBUG(\"QueueThread[%s]::wait() caller thread[%s] acquired stop lock\",\n name_.c_str(), caller_thread_id.c_str());\n // Block caller thread\n stop_cv_.wait(lock, [this]() {\n bool wait_condition = stop_requested_ && guard_queue_.size() == 0;\n GXF_LOG_DEBUG(\"stop_requested_[%d] && guard_queue_.size()[%d], cv wait condition[%d]\",\n stop_requested_.load(), guard_queue_.size(), wait_condition);\n return wait_condition; });\n // Try join the thread, thread safe\n joinThread();\n }\n\n private:\n /**\n * Thread safe join thread\n */\n void joinThread() {\n std::string caller_thread_id = callerThreadId();\n GXF_LOG_DEBUG(\"QueueThread[%s]::joinThread() caller thread[%s] acquiring join lock...\",\n name_.c_str(), caller_thread_id.c_str());\n\n // Ensure only one caller can join the thread\n std::lock_guard lock(join_mutex_);\n\n GXF_LOG_DEBUG(\"QueueThread[%s]::joinThread() caller thread[%s] acquired join lock\",\n name_.c_str(), caller_thread_id.c_str());\n if (thread_.joinable()) {\n GXF_LOG_DEBUG(\"QueueThread[%s]::joinThread() got its thread joinable(), joining...\",\n name_.c_str());\n thread_.join();\n GXF_LOG_DEBUG(\"QueueThread[%s]::joinThread() got its thread joined\", name_.c_str());\n joined_ = true;\n }\n }\n\n /**\n * Thread loop listening and processing tasks\n */\n void threadLoop() {\n while (true) {\n try {\n Entry entry = guard_queue_.pop();\n if (entry.is_stop_signal) {\n GXF_LOG_INFO(\"QueueThread[%s]::threadLoop() return\", STR(name_));\n return; // okay to return\n }\n if (stop_requested_ && guard_queue_.size() == 0) {\n // Exit loop if stop is requested and all entries are processed\n break;\n }\n bool result = run_function_(std::move(entry.user_item));\n entry.promise.set_value(result);\n if (!result) {\n GXF_LOG_INFO(\"QueueThread[%s]::threadLoop() return and stop\", STR(name_));\n break; // don't return\n }\n }\n catch (const std::exception& e) { // unexpected but continue\n GXF_LOG_ERROR(\"QueueThread:%s %s\", STR(name_), e.what());\n // move on to next\n continue;\n }\n catch (...) { // unexpected\n GXF_LOG_ERROR(\n \"QueueThread:%s internal unexpected error, may cause stop\", STR(name_));\n // Usually can move on to next, but need to check\n continue;\n }\n }\n\n GXF_LOG_DEBUG(\"threadLoop() break while loop\");\n // Clear the queue before exiting the thread loop\n guard_queue_.clear();\n // unblock external thread blocking on wait() call\n stop_requested_ = true;\n // Notify that the thread is about to exit after processing all entries\n stop_cv_.notify_all();\n }\n\n private:\n // basic member variables\n std::thread thread_;\n std::string name_;\n RunFunction run_function_;\n GuardQueue guard_queue_;\n\n // member variable for stopping\n std::atomic stop_requested_{false};\n std::mutex stop_mutex_;\n std::condition_variable stop_cv_;\n\n // member variable for joining thread\n std::mutex join_mutex_;\n bool joined_ = false;\n\n private:\n std::string callerThreadId() {\n pid_t tid = syscall(SYS_gettid);\n std::stringstream ss;\n ss << tid;\n return ss.str();\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_GEMS_QUEUE_THREAD_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/staging_queue/staging_queue.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_GEMS_STAGING_QUEUE_HPP\n#define NVIDIA_GXF_STD_GEMS_STAGING_QUEUE_HPP\n\n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"gxf/std/gems/staging_queue/staging_queue_iterator.hpp\"\n\nnamespace gxf {\nnamespace staging_queue {\n\n// Defines the behavior of a StagingQueue in case an element is added while the queue is already\n// full.\nenum class OverflowBehavior {\n // Pops oldest item to make room for the incoming item.\n kPop,\n // Rejects the incoming item.\n kReject,\n // The queue goes into an error state. Currently this raises a PANIC.\n kFault\n};\n\n// A thread-safe double-buffered queue implemented based on a ring buffer.\n//\n// This data structure provides a queue-like interface to a collection of items. When items are\n// added to the queue with the function push they are placed into a backstage area. The pop\n// function and query functions like size, peek or latest only operate on items on\n// the main stage. Items are moved from the backstage to the main stage by calling the sync\n// function. The queue only provides a fixed number of slots for elements. If elements are added to\n// a full queue a user-selected strategy is used to determine how to proceed. Note that the overflow\n// strategy can by triggered when calling push in case the backstage area is full, or when calling\n// sync in case the main stage is too full to receive all items from the backstage. When items are\n// removed from the queue they are overwritten with a user-defined default value. This is useful\n// for example in case shared pointers are stored in the queue. All functions of this type are\n// protected by a common mutex thus making this a thread-safe type. The queue is implemented as a\n// ring buffer internally.\n//\n// The following diagram depicts an example of a queue with a total capacity of four items. It\n// currently stores three items in the main stage and two items in the backstage. O indicates\n// empty slots, X indicates (filled) main stage slots and B indicates (filled) backstage slots.\n// There are three empty slots as neither main stage nor backstage are at full capacity. If the\n// sync function would be called in this situation the overflow behavior would be triggered as\n// the main stage does not have enough room to receive all items from the backstage.\n//\n// # start of ringbuffer # end of ringbuffer\n// | |\n// | O | X | X | X | B | B | O | O |\n// | | |\n// | | # end\n// # begin |\n// # backstage\n//\ntemplate \nclass StagingQueue {\n public:\n using const_iterator_t = StagingQueueIterator;\n\n // Creates a new staging queue. 'capacity' indicates the maximum number of elements allowed in\n // the queue. Note that the queue will allocate memory to hold two times capacity slots of item\n // type T. 'overflow_behavior' defines what will happen if a new item is added to a full queue.\n // 'null' is the default element which is used for empty slots. If an element is removed from the\n // queue the slot it occupied is set to this value.\n StagingQueue(size_t capacity, OverflowBehavior overflow_behavior, T null);\n\n // Creates an empty staging queue with no capacity and Fault overflow behavior\n StagingQueue();\n\n // Gets the overflow behavior which is used by this queue\n OverflowBehavior overflow_behavior() const;\n\n // Returns true if there are no elements in the main stage of the queue.\n // Identical to 'size() == 0;'\n bool empty() const;\n // Returns the number of elements in the main stage of the queue.\n size_t size() const;\n // Returns the maximum number of elements which can be stored in the main stage.\n size_t capacity() const;\n\n // Returns the number of elements in the back main stage of the queue.\n size_t back_size() const;\n\n // Gets the item at position 'index' in the main stage of the queue starting with the oldest item.\n // Returns a reference to the null object if there are no items in the main stage.\n const T& peek(size_t index = 0) const;\n // Gets the item at position 'index' in the back stage of the queue starting with the oldest item.\n // Returns a reference to the null object if there are no items in the back stage.\n const T& peek_backstage(size_t index = 0) const;\n // Gets the item at position 'index' in the main stage of the queue starting with the newest item.\n // Returns a reference to the null object if there are no items in the main stage.\n // Identical to 'peek(size() - 1 - index)'.\n const T& latest(size_t index = 0) const;\n\n // Gives an iterator pointing to the first element in the main stage.\n const_iterator_t begin() const;\n // Gives an iterator pointing to the element after the last element in the main stage.\n const_iterator_t end() const;\n\n // Removes the oldest item from the queue's main stage and returns it. In case there are no items\n // in the main stage this function simply returns a copy of the null object. This function\n // invalidates iterators returned by begin() or end().\n T pop();\n // Removes all items from the main stage. This function invalidates iterators in the same way\n // as the pop() function.\n void popAll();\n\n // Adds a new item to the back stage. In case the back stage is at capacity the overflow behavior\n // is used to decide what to do. The added item will NOT be visible to any other functions which\n // operate on the main stage, like size, peek, pop or similar, until 'sync' is called.\n bool push(T item);\n\n // Moves all items from the back stage to the main stage. In case the main stage is too full\n // to receive all items from the back stage the specified overflow behavior is used to decide what\n // to do. This function invalidates iterators in the same way as the pop() function.\n bool sync();\n\n private:\n // Returns the item in the underlying ringbuffer which is at position 'index' relative to the\n // start of the ring buffer.\n const T& at(size_t index) const { return items_[index % items_.size()]; }\n T& at(size_t index) { return items_[index % items_.size()]; }\n\n // The maximum number of items in the main stage and back stage. Total number items in the queue\n // is two times capacity.\n const size_t capacity_;\n // This behavior defines if either push or sync are called but the main stage contains too many\n // items already.\n const OverflowBehavior overflow_behavior_;\n\n // The null value is used for empty slots. It is also used as return value for peek and latest\n // in case the given index is out of bounds.\n T null_;\n\n // The container which holds the elements of the main stage and back stage. The container\n // allocates memory in the constructor and does not change it's capacity thereafter.\n std::vector items_;\n\n // Index of the first element of the main stage. The value of begin_ is guaranteed to be in the\n // range {0, ..., items_.size() - 1}.\n size_t begin_;\n\n // Number of elements in the mainstage.\n size_t num_mainstage_;\n // Number of elements in the backstage.\n size_t num_backstage_;\n\n // This mutext protects all functions from concurrent access.\n mutable std::mutex mutex_;\n};\n\n//--------------------------------------------------------------------------------------------------\n\ntemplate \nStagingQueue::StagingQueue(size_t capacity, OverflowBehavior overflow_behavior, T null)\n : capacity_(capacity),\n overflow_behavior_(overflow_behavior),\n null_(null),\n items_(2 * capacity, null),\n begin_(0),\n num_mainstage_(0),\n num_backstage_(0) {}\n\ntemplate \nStagingQueue::StagingQueue()\n : capacity_(0),\n overflow_behavior_(OverflowBehavior::kFault),\n null_(),\n items_(0),\n begin_(0),\n num_mainstage_(0),\n num_backstage_(0) {}\n\ntemplate \nOverflowBehavior StagingQueue::overflow_behavior() const {\n // Mutex not necessary as overflow_behavior_ is immutable.\n return overflow_behavior_;\n}\n\ntemplate \nbool StagingQueue::empty() const {\n std::lock_guard lock(mutex_);\n return num_mainstage_ == 0;\n}\n\ntemplate \nsize_t StagingQueue::size() const {\n std::lock_guard lock(mutex_);\n return num_mainstage_;\n}\n\ntemplate \nsize_t StagingQueue::capacity() const {\n // Mutex not necessary as capacity_ is immutable.\n return capacity_;\n}\n\ntemplate \nsize_t StagingQueue::back_size() const {\n std::lock_guard lock(mutex_);\n return num_backstage_;\n}\n\ntemplate \nconst T& StagingQueue::peek(size_t index) const {\n std::lock_guard lock(mutex_);\n if (index < num_mainstage_) {\n return at(begin_ + index);\n } else {\n return null_;\n }\n}\n\ntemplate \nconst T& StagingQueue::peek_backstage(size_t index) const {\n std::lock_guard lock(mutex_);\n if (index < num_backstage_) {\n const size_t begin_backstage = begin_ + num_mainstage_;\n return at(begin_backstage + index);\n } else {\n return null_;\n }\n}\n\ntemplate \nconst T& StagingQueue::latest(size_t index) const {\n std::lock_guard lock(mutex_);\n if (index < num_mainstage_) {\n return at(begin_ + num_mainstage_ - index - 1);\n } else {\n return null_;\n }\n}\n\ntemplate \ntypename StagingQueue::const_iterator_t StagingQueue::begin() const {\n return const_iterator_t(items_.data(), items_.size(), begin_);\n}\n\ntemplate \ntypename StagingQueue::const_iterator_t StagingQueue::end() const {\n return const_iterator_t(items_.data(), items_.size(), begin_ + num_mainstage_);\n}\n\ntemplate \nT StagingQueue::pop() {\n std::lock_guard lock(mutex_);\n T result = null_;\n if (num_mainstage_ > 0) {\n std::swap(at(begin_++), result);\n num_mainstage_--;\n }\n begin_ %= items_.size();\n return result;\n}\n\ntemplate \nvoid StagingQueue::popAll() {\n std::lock_guard lock(mutex_);\n const size_t begin_backstage = begin_ + num_mainstage_;\n while (begin_ < begin_backstage) {\n at(begin_++) = null_;\n }\n begin_ %= items_.size();\n num_mainstage_ = 0;\n}\n\ntemplate \nbool StagingQueue::push(T item) {\n std::lock_guard lock(mutex_);\n const size_t begin_backstage = begin_ + num_mainstage_;\n if (num_backstage_ == capacity_) {\n // Trying to add a item to a full backstage.\n switch (overflow_behavior_) {\n case OverflowBehavior::kPop: {\n // Move items in back stage one over. This removes the oldest item and makes room for one\n // new item.\n const size_t backstage_end = begin_backstage + num_backstage_;\n for (size_t i = begin_backstage + 1; i < backstage_end; i++) {\n at(i - 1) = std::move(at(i));\n }\n // Add new item at the end of the backstage.\n at(backstage_end - 1) = std::move(item);\n } break;\n case OverflowBehavior::kReject:\n // Don't add the new item to the backstage.\n break;\n case OverflowBehavior::kFault:\n return false;\n // FIXME \"Added an item to a full queue while using the 'Fault' overflow behavior.\"\n default:\n // FIXME \"Invalid parameter\"\n return false;\n }\n } else {\n // Add the new item to the end of the backstage.\n at(begin_backstage + num_backstage_) = std::move(item);\n num_backstage_++;\n }\n return true;\n}\n\ntemplate \nbool StagingQueue::sync() {\n std::lock_guard lock(mutex_);\n // Add back stage items to main stage\n num_mainstage_ += num_backstage_;\n num_backstage_ = 0;\n // Handle overflow if necessary\n if (num_mainstage_ > capacity_) {\n switch (overflow_behavior_) {\n case OverflowBehavior::kPop: {\n // Make sure that main and back stage together don't exceed capacity. Remove excess items\n // starting with the first item in the main stage. This effectively pops the oldest items to\n // make room for new items.\n const size_t new_begin = begin_ + num_mainstage_ - capacity_;\n while (begin_ < new_begin) {\n at(begin_++) = null_;\n }\n num_mainstage_ = capacity_;\n } break;\n case OverflowBehavior::kReject:\n // Make sure that main and back stage together don't exceed capacity. Remove excess items\n // starting with the last item in the back stage. This effectively rejects new items.\n while (num_mainstage_ > capacity_) {\n at(begin_ + --num_mainstage_) = null_;\n }\n break;\n case OverflowBehavior::kFault:\n return false;\n // FIXME \"Added items to a full queue while using the 'Fault' overflow behavior.\";\n default:\n // FIXME \"Invalid parameter\"\n return false;\n }\n }\n begin_ %= items_.size();\n return true;\n}\n\n} // namespace staging_queue\n} // namespace gxf\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/staging_queue/staging_queue_iterator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_GEMS_STAGING_QUEUE_ITERATOR_HPP\n#define NVIDIA_GXF_STD_GEMS_STAGING_QUEUE_ITERATOR_HPP\n\n#include \n\nnamespace gxf {\nnamespace staging_queue {\n\n// A forward iterator for a staging queue.\n//\n// This type can be used to iterate through the items of the main stage of a staging queue. (It\n// could be used to iterate over any part of the ring buffer, but is only used for the main stage.)\n// The iterator correctly \"wraps around\" the ring buffer in case the iterated sequence spans over\n// the end of the ring buffer. This iterator could in theory also be used to loop over the range\n// multiple times by adding multiples of size to the end index, however it is not used in this\n// fashion by the staging queue.\n//\n// Let's take the example of a staging queue which stores four items (capacity = 2) as depicted in\n// the diagram below. An iterator using index=3 would point to the third element. An iterator using\n// index=5 would point to the second element in the sequence. If these two iterators would be used\n// as begin and end of a range iteration would \"wrap around\" and iterate over the items A and B.\n//\n// 0 1 2 3 4\n// # # # # #\n// | B | O | O | A |\n// | |\n// | # begin\n// # end\n//\n// Note that the member functions of this type are part of the standard implementation for a\n// forward iterator. Please refer to the C++ standard definition for forward iterators for details.\ntemplate \nclass StagingQueueIterator {\n public:\n using difference_type = std::ptrdiff_t;\n using value_type = T;\n using reference = const T&;\n using pointer = const T*;\n\n // Creates an empty (invalid) iterator\n StagingQueueIterator() : data_(nullptr), size_(0), index_(0) {}\n\n // Creates and iterator based on a sequence of items pointed to by 'data' which stores 'size'\n // number of items. The given 'index' indicates the position of the element in the underlying\n // sequence modulo the length of the sequence.\n StagingQueueIterator(pointer data, size_t size, size_t index)\n : data_(data), size_(size), index_(index) {}\n\n StagingQueueIterator(const StagingQueueIterator& other) = default;\n StagingQueueIterator& operator=(const StagingQueueIterator& other) = default;\n StagingQueueIterator(StagingQueueIterator&& other) = default;\n StagingQueueIterator& operator=(StagingQueueIterator&& other) = default;\n\n ~StagingQueueIterator() = default;\n\n const StagingQueueIterator& operator++() {\n ++index_;\n return *this;\n }\n StagingQueueIterator operator++(int) { return StagingQueueIterator(data_, size_, index_++); }\n\n reference operator*() const { return data_[index_ % size_]; }\n pointer operator->() const { return data_ + (index_ % size_); }\n\n bool operator==(const StagingQueueIterator& rhs) const {\n return data_ == rhs.data_ && size_ == rhs.size_ && index_ == rhs.index_;\n }\n bool operator!=(const StagingQueueIterator& rhs) const { return !(*this == rhs); }\n\n private:\n // A pointer to the sequence of items to which this iterator refers.\n const pointer data_;\n\n // The length of the sequence pointer to by 'data_'.\n const size_t size_;\n\n // The index of the item in the sequence to which this iterator points. The index is taken modulo\n // 'size_' when accessing 'data_'.\n size_t index_;\n};\n\n} // namespace staging_queue\n} // namespace gxf\n\nnamespace std {\n\ntemplate \nstruct iterator_traits> {\n using difference_type = typename gxf::staging_queue::StagingQueueIterator::difference_type;\n using value_type = typename gxf::staging_queue::StagingQueueIterator::value_type;\n using reference = typename gxf::staging_queue::StagingQueueIterator::reference;\n using pointer = typename gxf::staging_queue::StagingQueueIterator::pointer;\n using iterator_category = std::forward_iterator_tag;\n};\n\n} // namespace std\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/suballocators/first_fit_allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_GEMS_SUBALLOCATORS_FIRST_FIT_ALLOCATOR_HPP\n#define NVIDIA_GXF_STD_GEMS_SUBALLOCATORS_FIRST_FIT_ALLOCATOR_HPP\n\n#include \n#include \n#include \n#include \n\n#include \"common/expected.hpp\"\n#include \"gxf/std/gems/suballocators/first_fit_allocator_base.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Memory management class.\n// It pre-allocates memory for a given type and allow acquiring chunk of memory and releasing them.\n// Only the allocate function is doing some memory allocation, other functions are using constant\n// amount of memory on the stack.\ntemplate\nclass FirstFitAllocator {\n public:\n // Expected type used by this class.\n template \n using expected_t = nvidia::Expected;\n // Unexpected type used by this class.\n using unexpected_t = nvidia::Unexpected;\n\n FirstFitAllocator() = default;\n\n // Allocates the require memory to handle the query for a chunk of memory of a give size .\n // It fails if size is invalid (too big or negative).\n // Note that a minimum chunk size to be considered can be provided. It means the memory allocated\n // will always be a multiple of this size. This can help speed up the memory allocation, however\n // it loses control on the exact allocated size.\n // The total memory allocated will be around sizeof(T) * size + 32 * size / chunk_size.\n expected_t allocate(const int32_t size, const int chunk_size = 1) {\n if (buffer_.get() != nullptr) {\n return unexpected_t(FirstFitAllocatorBase::Error::kAlreadyInUse);\n }\n if (size < 0 || chunk_size <= 0) {\n return unexpected_t(FirstFitAllocatorBase::Error::kInvalidSize);\n }\n chunk_size_ = chunk_size;\n const int32_t number_of_chunks = getNumberOfChunks(size);\n // Allocate memory\n buffer_.reset(new(std::nothrow) T[number_of_chunks * chunk_size_]);\n if (buffer_.get() == nullptr) {\n return unexpected_t(FirstFitAllocatorBase::Error::kOutOfMemory);\n }\n // Prepare the memory management.\n auto res = memory_management_.allocate(number_of_chunks);\n if (!res) {\n return unexpected_t(res.error());\n }\n return size;\n }\n\n // Attempts to acquire a block of memory of a given size.\n // If such a contiguous block exists, it will return a pointer to that block and the actual size\n // acquired (will be the smallest multiple of chunk_size_ that exceed or equal size).\n // If no block exists, it will return FirstFitAllocatorBase::Error::kOutOfMemory.\n expected_t> acquire(const int32_t size) {\n const int32_t number_of_chunks = getNumberOfChunks(size);\n auto res = memory_management_.acquire(number_of_chunks);\n if (!res) {\n return unexpected_t(res.error());\n }\n return std::make_pair(&buffer_.get()[res.value() * chunk_size_],\n number_of_chunks * chunk_size_);\n }\n\n // Releases a block of memory that has been acquired with the function above.\n // If there was no `acquire(size)` that returned this pointer, this query will fail, otherwise it\n // will free the block of memory for further acquisition.\n // Note once a block of memory has been released, it can't be released again.\n expected_t release(const T* ptr) {\n const int32_t index = std::distance(buffer_.get(), ptr);\n if (index % chunk_size_ != 0) {\n return unexpected_t(FirstFitAllocatorBase::Error::kInvalidSize);\n }\n return memory_management_.release(index / chunk_size_);\n }\n\n private:\n // Returns the number of chunks of memory needed to have at least a given size.\n int32_t getNumberOfChunks(const int32_t size) const {\n return (size + chunk_size_ - 1) / chunk_size_;\n }\n\n // Real memory management.\n FirstFitAllocatorBase memory_management_;\n // Size of the chunk of memory. Only multiple of this size can be allocated. Whenever a request is\n // made, the allocated size will be the smaller multiple of chunk_size_ that is not smaller than\n // the requested size.\n int32_t chunk_size_;\n // Buffer holding the pre-allocated memory that is provided on demand.\n std::unique_ptr buffer_{nullptr};\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_GEMS_SUBALLOCATORS_FIRST_FIT_ALLOCATOR_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/suballocators/first_fit_allocator_base.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_GEMS_SUBALLOCATORS_FIRST_FIT_ALLOCATOR_BASE_HPP\n#define NVIDIA_GXF_STD_GEMS_SUBALLOCATORS_FIRST_FIT_ALLOCATOR_BASE_HPP\n\n#include \n#include \n#include \n#include \n\n#include \"common/expected.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Memory management helper class, it keeps track of what part of a big chunk of memory has been\n// allocated and can efficiently find the first available chunk of memory that fits a given size.\n// This class works only with indexes and rely on an external class to hold the memory.\n// Internally it uses binary segment tree to keep track the biggest available block in a given area\n// of the the memory. All the operation should take a logarithmic time.\nclass FirstFitAllocatorBase {\n public:\n // Error codes used by the classes of this file.\n enum class Error {\n // Returned when the suballocators is already in use and some memory has not been released yet.\n kAlreadyInUse,\n // Returned if the size is invalid (negative or too big).\n kInvalidSize,\n // Returned if the class can't allocate enough memory.\n kOutOfMemory,\n // Returned if we attempt to release a block of memory not allocated yet.\n kBlockNotAllocated,\n // This error happens when there is logically issue during the execution. This should never\n // happen.\n kLogicError,\n };\n // Expected type used by this class.\n template \n using expected_t = nvidia::Expected;\n // Unexpected type used by this class.\n using unexpected_t = nvidia::Unexpected;\n\n FirstFitAllocatorBase();\n // Allocates the require memory to handle the query for a chunk of memory of a give size .\n // It requires 32 * 2^ceil(log2(size)) Bytes of memory.\n // It fails if size is invalid (too big or negative).\n expected_t allocate(int32_t size);\n // Attempts to acquire a block of memory of a given size.\n // If such a contiguous block exists, it will return the lowest index where such a block exist.\n // This block will be blocked until a call to release(index, size) is made.\n // If no block exists, it will return Error::kOutOfMemory.\n expected_t acquire(int32_t size);\n // Releases a block of memory that has been acquired with the function above.\n // If there was no `acquire(size)` that returned `index`, this query will fail, otherwise it will\n // free the block of memory for further acquisition.\n // Note once a block of memory has been released, it can't be released again.\n expected_t release(int32_t index);\n\n private:\n // Helper data structure to efficiently find a block of memory of a given size.\n // It represents a node in a binary segment tree.\n struct Memory {\n // Updates the node using both children.\n // size = l.size + r.size\n // left = l.left or l.size + r.left iff l.max == l.size\n // right = r.right or r.right + l.right iff r.max == r.size\n // max = max(l.max, r.max, l.right + r.left)\n void update(const Memory& left_child, const Memory& right_child);\n // Marks a node as being free (if == 1) or acquired (if == 0).\n void set(int32_t free);\n\n // Left and right store the size of available memory which start respectively from the left or\n // right side of the subtree.\n int32_t left, right;\n // Max is the size of biggest available block in the subtree.\n // When a block is starting at the given index, the leaf will contain -1.\n int32_t max;\n // Size is constant overtime and represent the size of the subtree.\n // When a block has been acquired, size will contain the size that has been acquired from the\n // given position.\n int32_t size;\n };\n\n // Updates a path from a given node to the root.\n void propagateToRoot(int32_t idx);\n // Updates a segment of the tree [left, right[ and marks it as free or acquired.\n void update(int32_t left, int32_t right, int32_t free);\n\n // Hold the segment tree memory.\n std::unique_ptr tree_;\n // The total size available at the beginning.\n int32_t size_;\n // Helper index that helps pointing toward the leaves of the tree.\n int32_t last_layer_first_index_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_GEMS_SUBALLOCATORS_FIRST_FIT_ALLOCATOR_BASE_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/timed_job_list/timed_job_list.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_GEMS_TIMED_JOB_LIST_TIMED_JOB_LIST_HPP_\n#define NVIDIA_GXF_STD_GEMS_TIMED_JOB_LIST_TIMED_JOB_LIST_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A thread-safe queue which sorts by target execution time. It provides a blocking pop to get\n// jobs precisely when the time is right.\n// T: The type of jobs to store in the queue\n// Eq: (T,T) -> bool: true if jobs are identical\ntemplate \nclass TimedJobList {\n public:\n using Clock_t = std::function;\n\n TimedJobList(Clock_t clock) : clock_(clock), is_running_(false) {}\n // Number of queued jobs. This should only be used for logging purposes as it is not acquiring\n // a lock.\n size_t sizeUnsafe() const { return queue_.size(); }\n\n // thread-safe implementation to find number of queued jobs\n size_t size() const {\n std::unique_lock lock(queue_cv_mutex_);\n return items_.size();\n }\n\n // Adds a job to the queue to be executed at the given target time. O(log(n))\n bool insert(JobT job, int64_t target_time, int64_t slack, int priority);\n // Notify that a job has completed.\n void notifyDone(JobT job);\n // This is a blocking call which will wait for an job.\n void waitForJob(JobT&);\n // Removes a job from the queue if present. Returns true if the job was found and removed.\n bool remove(JobT job);\n // Sets the job list to a running state\n void start() { is_running_.store(true); }\n // Sets the job list to a stopped state and wakes all waiting threads to flush.\n void stop() {\n // Acquire the lock to ensure a thread isn't trying to acquire a job\n // while invoking stop.\n std::unique_lock lock(queue_cv_mutex_);\n // Stop the queue\n is_running_.store(false);\n // Wake all waiting threads\n queue_cv_.notify_all();\n }\n // Gets the target time of the next job; or returns an error if there is no job\n Expected getNextTargetTime() const {\n std::unique_lock lock(queue_cv_mutex_);\n if (queue_.empty()) {\n return Unexpected{GXF_QUERY_NOT_FOUND};\n } else {\n return queue_.top().target_time;\n }\n }\n // wakes up one waiting threads\n void wakeOne() { queue_cv_.notify_one(); }\n // wakes all waiting threads\n void wakeAll() { queue_cv_.notify_all(); }\n\n // Pops the next pending or waiting job regardless of their\n // target execution time\n Expected popFront() {\n std::unique_lock lock(queue_cv_mutex_);\n\n // return pending jobs first\n for (auto pending_job = pending_.begin(); pending_job != pending_.end(); ++pending_job) {\n Item result = *pending_job;\n pending_.erase(pending_job);\n return result.job;\n }\n\n // return waiting jobs next\n if (queue_.empty()) { return Unexpected{GXF_FAILURE}; }\n\n Item result = queue_.top();\n queue_.pop();\n items_.erase(result.job);\n return result.job;\n }\n\n // Checks if there any pending or waiting jobs\n bool empty() const {\n std::unique_lock lock(queue_cv_mutex_);\n return queue_.empty() && pending_.empty();\n }\n\n private:\n // We allow a small tolerance when executing jobs\n// static constexpr int64_t kTimeFudge = 100'000; // 0.1 ms\n static constexpr int64_t kTimeFudge = 1; // 100 ns\n\n // Helper class used to store jobs with additional information\n struct Item {\n // The job to execute\n JobT job;\n // The target time at which the job should be executed\n int64_t target_time;\n // The amount of time the target time can slip by\n int64_t slack;\n // The priority is used as a tie breaker when two jobs would be scheduled close together.\n int priority;\n };\n\n // Sorts jobs such that the earliest non-running job has highest priority\n struct ItemPriorityCmp {\n bool operator()(const Item& a, const Item& b) {\n // If two jobs with their slack times are scheduled within a small\n // interval of each other check their priorities,\n // Otherwise earliest deadline goes first.\n const int64_t a_time = a.target_time + a.slack;\n const int64_t b_time = b.target_time + b.slack;\n\n if (std::abs(a_time - b_time) < kTimeFudge && a.priority != b.priority) {\n return a.priority < b.priority;\n } else {\n return a_time > b_time;\n }\n }\n };\n\n // This function pointer should be set to utilize the desired clock for the queue.\n Clock_t clock_;\n // state variable to control if threads should block on waiting for jobs\n std::atomic is_running_;\n\n mutable std::mutex queue_cv_mutex_;\n std::condition_variable queue_cv_;\n\n // List of future events sorted by their scheduled execution time.\n std::priority_queue, ItemPriorityCmp> queue_;\n\n // Item lookup to avoid duplicates\n std::unordered_set items_;\n\n // List of events overdue, we have passed their scheduled execution time but have not been able to\n // run yet.\n std::list pending_;\n};\n\n// -------------------------------------------------------------------------------------------------\n\ntemplate \nbool TimedJobList::insert(JobT job, int64_t target_time, int64_t slack, int priority) {\n {\n std::unique_lock lock(queue_cv_mutex_);\n if (items_.find(job) != items_.end()) { return false; }\n items_.insert(job);\n queue_.push(Item{std::move(job), target_time, slack, priority});\n }\n queue_cv_.notify_one();\n return true;\n}\n\ntemplate \nvoid TimedJobList::notifyDone(JobT job) {\n std::unique_lock lock(queue_cv_mutex_);\n wakeOne();\n}\n\n// Removes a job from the pending list or priority queue and from the items_ tracking set.\n// Since std::priority_queue doesn't support direct element removal, this method rebuilds\n// the queue excluding the target job when necessary. Returns true if the job was found\n// and successfully removed, false if the job wasn't present in any container.\ntemplate \nbool TimedJobList::remove(JobT job) {\n std::unique_lock lock(queue_cv_mutex_);\n\n // Check if the job exists in our tracking set\n auto it = items_.find(job);\n if (it == items_.end()) {\n return false; // Job not found\n }\n\n // Remove from items_\n items_.erase(it);\n\n // Check if job is in pending list and remove if found\n for (auto pending_it = pending_.begin(); pending_it != pending_.end(); ++pending_it) {\n if (pending_it->job == job) {\n pending_.erase(pending_it);\n return true;\n }\n }\n\n // If not in pending, it might be in the queue\n // Since std::priority_queue doesn't allow direct removal, we need to:\n // 1. Create a new queue\n // 2. Pop all elements from the old queue\n // 3. Push all elements except the one we want to remove into the new queue\n // 4. Swap the queues\n\n std::priority_queue, ItemPriorityCmp> new_queue;\n bool found = false;\n\n while (!queue_.empty()) {\n Item item = queue_.top();\n queue_.pop();\n\n if (item.job != job) {\n // Keep this item\n new_queue.push(item);\n } else {\n // Found the job to remove\n found = true;\n }\n }\n\n // Replace the old queue with the new one\n queue_.swap(new_queue);\n\n // Wake waiting threads to recalculate wait times\n wakeOne();\n\n return found;\n}\n\ntemplate \nvoid TimedJobList::waitForJob(JobT& job) {\n while (is_running_) {\n // Acquire the lock to check for a job\n std::unique_lock lock(queue_cv_mutex_);\n // Double check the running status as a stop could have been invoked.\n if (!is_running_) {\n return;\n }\n int64_t wait_duration = 0;\n const int64_t now = clock_();\n while (!queue_.empty()) {\n // We have a job, check if it is time for it\n Item top_item = queue_.top();\n const int64_t eta = top_item.target_time - now;\n // If the jobs target time is within our fudge factor fire now.\n if (eta <= kTimeFudge) {\n pending_.push_back(top_item);\n queue_.pop();\n } else {\n // wait till next eta minus a small window\n wait_duration = std::max(eta - kTimeFudge, static_cast(0));\n break;\n }\n }\n // Loop through the list of pending jobs to find one that can be run.\n for (auto pending_job = pending_.begin(); pending_job != pending_.end(); ++pending_job) {\n job = pending_job->job;\n pending_job->target_time = now;\n pending_.erase(pending_job);\n items_.erase(job);\n return;\n }\n // Wait for a new job or until time is up (the lock is released while waiting)\n if (wait_duration > 0) {\n queue_cv_.wait_for(lock, std::chrono::nanoseconds(wait_duration));\n } else {\n queue_cv_.wait(lock);\n }\n }\n}\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_GEMS_TIMED_JOB_LIST_TIMED_JOB_LIST_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/utils/time.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_GXF_STD_GEMS_UTILS_TIME_HPP_\n#define NVIDIA_GXF_GXF_STD_GEMS_UTILS_TIME_HPP_\n\n#include \n#include \n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/// @brief Converts time in seconds to a timestamp in nanoseconds\nint64_t TimeToTimestamp(double time);\n\n/// @brief Converts a timestamp Nanoseconds to seconds\ndouble TimestampToTime(int64_t timestamp);\n\n/// @brief Parses given text to return the desired period in nanoseconds.\n///\n/// @param text Text containing number and time-units, to be parsed for desired period\n/// @param cid cid of component for which text is being parsed\n/// @return Period in nanoseconds if successful, or otherwise one of the GXF error codes.\nExpected ParseRecessPeriodString(std::string text, const gxf_uid_t& cid);\n\ninline uint64_t getCurrentTimeUs() {\n using std::chrono::duration_cast;\n using std::chrono::system_clock;\n return duration_cast(system_clock::now().time_since_epoch()).count();\n}\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GXF_STD_GEMS_UTILS_TIME_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/video_buffer/allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_GEMS_VIDEO_BUFFER_HPP\n#define NVIDIA_GXF_STD_GEMS_VIDEO_BUFFER_HPP\n\n#include \n#include \n#include \"gxf/multimedia/video.hpp\"\n#include \"gxf/std/allocator.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\ntemplate \nstruct NoPaddingColorPlanes {};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width) : planes({gxf::ColorPlane(\"RGB\", 3, width * 3)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"BGR\", 3, width * 3)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"RGBA\", 4, width * 4)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"BGRA\", 4, width * 4)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"RGB\", 6, width * 6)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"BGR\", 6, width * 6)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"RGB\", 12, width * 12)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"BGR\", 12, width * 12)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"gray\", 1, width)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"gray\", 2, width * 2)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"gray\", 4, width * 4)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"gray\", 4, width * 4)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"Y\", 1, width),\n nvidia::gxf::ColorPlane(\"UV\", 2, width)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"Y\", 1, width),\n nvidia::gxf::ColorPlane(\"UV\", 2, width)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"Y\", 1, width),\n nvidia::gxf::ColorPlane(\"UV\", 2, width * 2)}) {}\n std::array planes;\n};\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"Y\", 1, width),\n nvidia::gxf::ColorPlane(\"UV\", 2, width * 2)}) {}\n std::array planes;\n};\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes({gxf::ColorPlane(\"R\", 1, width), gxf::ColorPlane(\"G\", 1, width),\n gxf::ColorPlane(\"B\", 1, width)}) {}\n std::array planes;\n};\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes({gxf::ColorPlane(\"R\", 2, width * 2), gxf::ColorPlane(\"G\", 2, width * 2),\n gxf::ColorPlane(\"B\", 2, width * 2)}) {}\n std::array planes;\n};\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes(\n {gxf::ColorPlane(\"R\", 4, width * 4), gxf::ColorPlane(\"G\", 4, width * 4),\n gxf::ColorPlane(\"B\", 4, width * 4)}) {}\n std::array planes;\n};\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes({gxf::ColorPlane(\"B\", 1, width), gxf::ColorPlane(\"G\", 1, width),\n gxf::ColorPlane(\"R\", 1, width)}) {}\n std::array planes;\n};\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes(\n {gxf::ColorPlane(\"R\", 2, width * 2), gxf::ColorPlane(\"G\", 2, width * 2),\n gxf::ColorPlane(\"B\", 2, width * 2)}) {}\n std::array planes;\n};\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes(\n {gxf::ColorPlane(\"B\", 4, width * 4), gxf::ColorPlane(\"G\", 4, width * 4),\n gxf::ColorPlane(\"R\", 4, width * 4)}) {}\n std::array planes;\n};\n// This includes the list of video buffer formats that supported for the allocator\nconstexpr bool IsSupportedVideoFormat(const gxf::VideoFormat format) {\n return format == gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_RGBA ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_BGRA ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY32F ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_B8_G8_R8 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_B16_G16_R16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_B32_G32_R32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_NV12 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_NV12_ER ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_NV24 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_NV24_ER;\n}\ntemplate::type* = nullptr>\ngxf::Expected AllocateUnpaddedVideoBuffer(\n gxf::Handle frame, uint32_t width, uint32_t height,\n gxf::MemoryStorageType storage_type,\n gxf::Handle allocator) {\n GXF_LOG_ERROR(\"Received unsupported video format!\");\n return gxf::Unexpected{GXF_FAILURE};\n}\ntemplate::type* = nullptr>\ngxf::Expected AllocateUnpaddedVideoBuffer(\n gxf::Handle frame, uint32_t width, uint32_t height,\n gxf::MemoryStorageType storage_type, gxf::Handle allocator) {\n if (width % 2 != 0 || height % 2 != 0) {\n GXF_LOG_ERROR(\n \"Error: expected even width and height but received %u width and %u height\",\n width, height);\n return gxf::Unexpected{GXF_FAILURE};\n }\n NoPaddingColorPlanes nopadding_planes(width);\n gxf::VideoFormatSize video_format_size;\n auto size = video_format_size.size(width, height, nopadding_planes.planes);\n std::vector color_planes{\n nopadding_planes.planes.begin(), nopadding_planes.planes.end()};\n gxf::VideoBufferInfo buffer_info{width, height, T, color_planes,\n gxf::SurfaceLayout::GXF_SURFACE_LAYOUT_PITCH_LINEAR};\n return frame->resizeCustom(buffer_info, size, storage_type, allocator);\n}\ntemplate\ngxf::Expected AllocateVideoBuffer(\n gxf::Handle frame, uint32_t width, uint32_t height,\n gxf::SurfaceLayout layout, gxf::MemoryStorageType storage_type,\n gxf::Handle allocator) {\n return frame->resize(width, height, layout, storage_type, allocator);\n}\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/graph_driver.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_GRAPH_DRIVER_HPP_\n#define NVIDIA_GXF_GRAPH_DRIVER_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/std/gems/queue_thread/queue_thread.hpp\"\n#include \"gxf/std/graph_driver_worker_common.hpp\"\n#include \"gxf/std/ipc_client.hpp\"\n#include \"gxf/std/ipc_server.hpp\"\n#include \"gxf/std/system.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * ECS layer Component, resolving segments connection addresses\n * Works with GraphWorker as server-client pair\n *\n * Has event-based thread, IPC server, and IPC client\n *\n * Segments connection graph:\n * 1. Users to provide, via config or add connection API\n *\n * Resolve address of each segment pair:\n * 1. Listen to remote GraphWorkers that each runs one or more segments.\n * 2. Register all GraphWorkers until all segments in static graph are discovered\n * 3. Resolve connection address between each segment pair\n * 4. Send result address to each target segment via GraphWorker that manages the segment\n*/\nclass GraphDriver : public System {\n public:\n using ConnectionMap = std::unordered_map;\n using GxfSystemThread = QueueThread;\n GraphDriver() = default;\n\n gxf_result_t schedule_abi(gxf_uid_t eid) override;\n gxf_result_t unschedule_abi(gxf_uid_t eid) override;\n gxf_result_t runAsync_abi() override;\n gxf_result_t stop_abi() override;\n gxf_result_t wait_abi() override;\n gxf_result_t event_notify_abi(gxf_uid_t eid, gxf_event_t event) override;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n\n // C++ API exclusive\n Expected addSegmentConnection(const std::string& source, const std::string& target);\n\n private:\n /**\n * Member thread event-based entrance\n */\n bool asyncRunnerCallback(std::string event, GraphDriver* self);\n\n /**\n * Service to register a remote GraphWorker\n */\n Expected onRegisterGraphWorker(const std::string& resource, const std::string& payload);\n\n /**\n * Service to record completion of each GraphWorker\n * then finally gently tear down this GraphDriver\n */\n Expected onGraphWorkerComplete(const std::string& resource, const std::string& payload);\n\n /**\n * After discover all segments from remote GraphWorkers, resolve segments connection\n * then send remote request to update connection addresses\n */\n Expected resolveConnections();\n\n /**\n * After update segments connection in each segment, they're ready to execute\n * send remote request to all GraphWorkers to run the segments\n */\n Expected executeWorkers();\n\n /**\n * Send remote request to all GraphWorkers to deactivate the segments\n */\n Expected deactivateWorkers();\n\n /**\n * Send remote request to all GraphWorkers to stop the segments\n */\n Expected stopWorkers();\n\n private:\n // Communication layer\n Parameter> server_;\n Parameter> client_;\n Parameter> list_of_connections_;\n ConnectionMap connections_;\n ConnectionMap reverse_connections_;\n std::set segment_names_;\n std::unordered_map> workers_;\n std::set completed_workers_;\n std::unique_ptr driver_thread_;\n std::set requested_segment_names_;\n std::unordered_map segment_ip_address_;\n\n private:\n struct Event {\n static constexpr const char* kNotInitialized = \"kNotInitialized\";\n static constexpr const char* kResolveConnections = \"kResolveConnections\";\n static constexpr const char* kExecuteWorkers = \"kExecuteWorkers\";\n static constexpr const char* kDeactivateWorkers = \"kDeactivateWorkers\";\n static constexpr const char* kStopWorkers = \"kStopWorkers\";\n };\n};\n\n/**\n * Utils\n*/\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(\n gxf_context_t context, gxf_uid_t component_uid, const char* key,\n const YAML::Node& node, const std::string& prefix) {\n if (!node.IsMap()) {\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n GraphDriver::ConnectionMap connections;\n for (const auto& p : node) {\n const std::string k = p.first.as();\n const auto maybe = ParameterParser::Parse(\n context, component_uid, k.c_str(), node[k], prefix);\n if (!maybe) {\n return ForwardError(maybe);\n }\n connections[k] = maybe.value();\n }\n return connections;\n }\n};\n\n\ntemplate <>\nstruct ParameterWrapper {\n // Wrap the value to a YAML::Node instance\n static Expected Wrap(\n gxf_context_t context,\n const GraphDriver::ConnectionMap& value) {\n YAML::Node node(YAML::NodeType::Map);\n for (auto &i : value) {\n auto maybe = ParameterWrapper::Wrap(context, i.second);\n if (!maybe) {\n return ForwardError(maybe);\n }\n node[i.first] = maybe.value();\n }\n return node;\n }\n};\n\ntemplate<>\nstruct ParameterWrapper> {\n static Expected Wrap(\n gxf_context_t context,\n const std::vector& value) {\n YAML::Node node(YAML::NodeType::Sequence);\n for (auto &h : value) {\n auto maybe = ParameterWrapper::Wrap(context, h);\n if (!maybe) {\n return Unexpected{maybe.error()};\n }\n node.push_back(maybe.value());\n }\n return node;\n }\n};\n\ntemplate <>\nstruct ParameterParser> {\n static Expected> Parse(\n gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n if (!node.IsSequence()) {\n const char* component_name = \"UNKNOWN\";\n GxfParameterGetStr(context, component_uid, kInternalNameParameterKey, &component_name);\n GXF_LOG_ERROR(\"Parameter '%s' in component '%s' must be a vector\", key, component_name);\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n std::vector result(node.size());\n for (size_t i = 0; i < node.size(); i++) {\n const auto maybe = ParameterParser::Parse(\n context, component_uid, key, node[i], prefix);\n if (!maybe) {\n return ForwardError(maybe);\n }\n result[i] = std::move(maybe.value());\n }\n return result;\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_DRIVER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/graph_driver_worker_common.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_GRAPH_DRIVER_WORKER_COMMON_HPP_\n#define NVIDIA_GXF_GRAPH_DRIVER_WORKER_COMMON_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/logger.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\nvoid parseIpAddress(const std::string& ip_address_port, std::string& ip_address, int& port);\n\nvoid parseSegmentEntityComponentName(\n const std::string& segment_entity_component_name,\n std::string& segment_name,\n std::string& entity_name,\n std::string& component_name);\n\n//\n// JSON schema parsing\n//\nstruct ComponentParam {\n struct ParamInfo {\n std::string key;\n std::string value;\n std::string value_type;\n static Expected strToBool(const std::string& str);\n static Expected strToInt32(const std::string& str);\n static Expected strToUInt32(const std::string& str);\n static Expected strToInt64(const std::string& str);\n static Expected strToUInt64(const std::string& str);\n static Expected strToFloat32(const std::string& str);\n static Expected strToFloat64(const std::string& str);\n static Expected strToUInt16(const std::string& str);\n };\n std::string segment_name;\n std::string entity_name;\n std::string component_name;\n std::vector params;\n // Helpers\n std::string serialize() const {\n return segment_name + \".\" + entity_name + \".\" + component_name;\n }\n};\n\nstruct ComponentInfo {\n std::string segment_name;\n std::string entity_name;\n std::string component_name;\n // Helpers\n std::string serialize() const {\n return segment_name + \".\" + entity_name + \".\" + component_name;\n }\n static ComponentInfo deserialize(const std::string& data) {\n std::istringstream stream(data);\n std::string segment;\n std::string entity;\n std::string component;\n std::getline(stream, segment, '.');\n std::getline(stream, entity, '.');\n std::getline(stream, component, '.');\n // Validate that all parts are present.\n if (segment.empty() || entity.empty() || component.empty()) {\n GXF_LOG_ERROR(\"Invalid data %s\", data.c_str());\n }\n\n return {segment, entity, component};\n }\n};\n\nstruct SegmentInfo {\n std::string segment_name;\n // key: \"Segment_name/Entity_name/UcxRx_name\"\n // value: \"10.0.0.1:3000\"\n std::map ip_port_address_map;\n};\n\nstruct WorkerInfo {\n std::string server_ip_address;\n std::string server_port;\n std::vector segment_info_list;\n std::string ip_port() const {\n return server_ip_address + \":\" + server_port;\n }\n};\n\nclass GraphDriverWorkerParser {\n public:\n GraphDriverWorkerParser() = default;\n\n static Expected>\n deserialize_onSetComponentParams(const std::string& payload);\n\n static Expected\n serialize_onSetComponentParams(const std::vector& component_param_list);\n\n static Expected\n deserialize_onRegisterGraphWorker(const std::string& payload);\n\n static Expected\n serialize_onRegisterGraphWorker(const WorkerInfo& worker_info);\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_DRIVER_WORKER_COMMON_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/graph_worker.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_GRAPH_WORKER_HPP_\n#define NVIDIA_GXF_GRAPH_WORKER_HPP_\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/std/gems/queue_thread/queue_thread.hpp\"\n#include \"gxf/std/graph_driver_worker_common.hpp\"\n#include \"gxf/std/ipc_client.hpp\"\n#include \"gxf/std/ipc_server.hpp\"\n#include \"gxf/std/system.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// copy tid from ucx extension\nstatic const gxf_tid_t ucx_transmitter_tid{0x58165d0378b74696, 0xb20071621f90aee7};\n\nstruct GraphSpec {\n std::string app_path;\n std::string param_path;\n std::string manifest_path;\n uint32_t severity = 3; // default severity\n};\n\n/**\n * SegmentRunner, context to run each graph segment\n*/\nclass SegmentRunner {\n public:\n using GxfSystemThread = QueueThread;\n // YAML API compose graph\n SegmentRunner(const std::string& name, const GraphSpec& graph_spec)\n : name_(name), graph_spec_(graph_spec) {\n runner_thread_ = std::make_unique(\n std::bind(&SegmentRunner::asyncRunnerCallback, this, std::placeholders::_1, this),\n name);\n }\n SegmentRunner(const std::string& name, const GraphSpec& graph_spec,\n std::shared_ptr worker_thread)\n : SegmentRunner(name, graph_spec) { // delegating to the first constructor\n worker_thread_ = worker_thread;\n }\n // C++ API compose graph\n SegmentRunner(const std::string& name, const gxf_context_t context)\n : name_(name), context_(context) {\n runner_thread_ = std::make_unique(\n std::bind(&SegmentRunner::asyncRunnerCallback, this, std::placeholders::_1, this),\n name);\n }\n SegmentRunner(const std::string& name, const gxf_context_t context,\n std::shared_ptr worker_thread)\n : SegmentRunner(name, context) {\n worker_thread_ = worker_thread;\n }\n // ~SegmentRunner();\n void stop();\n void wait();\n // combined/simplified gxf run sequence\n std::future asyncInitializeGxfGraph();\n std::future asyncActivateGxfGraph();\n std::future asyncRunGxfGraph();\n std::future runGxfGraph();\n std::future asyncDeactivateGxfGraph();\n std::future asyncDestroyGxfGraph();\n gxf_result_t setParameter(const std::string& entity_name, const std::string& comp_name,\n const std::string& key, const std::string& value, const std::string& value_type);\n Expected createSegmentInfo(const std::string& worker_host_ip);\n\n private:\n std::unique_ptr runner_thread_;\n std::shared_ptr worker_thread_;\n bool asyncRunnerCallback(std::string event, SegmentRunner* self);\n struct Event {\n // GXF C API sequence event\n static constexpr const char* kCreateGxfContext = \"kCreateContext\";\n static constexpr const char* kLoadGxfManifest = \"kLoadGxfManifest\";\n static constexpr const char* kLoadGxfGraph = \"kLoadGxfGraph\";\n static constexpr const char* kActivateGxfGraph = \"kActivateGxfGraph\";\n static constexpr const char* kNonBlockingRunGxfGraph = \"kNonBlockingRunGxfGraph\";\n static constexpr const char* kBlockingRunGxfGraph = \"kBlockingRunGxfGraph\";\n static constexpr const char* kInterruptGxfGraph = \"kInterruptGxfGraph\";\n static constexpr const char* kDeactivateGxfGraph = \"kDeactivateGxfGraph\";\n static constexpr const char* kDestroyGxfGraph = \"kDestroyGxfGraph\";\n };\n const std::string name_;\n const GraphSpec graph_spec_;\n gxf_context_t context_ = kNullContext;\n gxf_context_t s_signal_context_ = kNullContext;\n std::mutex context_mutex_;\n\n private:\n // gxf wrappers, non thread safe to gxf_context\n gxf_result_t wrapCreateGxfConext();\n gxf_result_t wrapLoadGxfManifest();\n gxf_result_t wrapLoadGxfGraph();\n gxf_result_t wrapActivateGxfGraph();\n gxf_result_t wrapBlockingRunGxfGraph();\n gxf_result_t wrapNonBlockingRunGxfGraph();\n gxf_result_t wrapInterruptGxfGraph();\n gxf_result_t wrapDeactivateGxfGraph();\n gxf_result_t wrapDestroyGxfGraph();\n};\n\n\n/**\n * ECS layer Component, manages executing a set of segments\n * Works with GraphDriver as server-client pair\n *\n * Has event-based thread, IPC server, and IPC client.\n *\n * Segments to manage:\n * 1. Users to provide, via config or add segment context API\n*/\nclass GraphWorker : public System {\n public:\n using GxfSystemThread = QueueThread;\n GraphWorker() = default;\n\n gxf_result_t schedule_abi(gxf_uid_t eid) override;\n gxf_result_t unschedule_abi(gxf_uid_t eid) override;\n gxf_result_t runAsync_abi() override;\n gxf_result_t stop_abi() override;\n gxf_result_t wait_abi() override;\n gxf_result_t event_notify_abi(gxf_uid_t eid, gxf_event_t event) override;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n\n // C++ API exclusive\n Expected addSegment(const std::string& name, const gxf_context_t context);\n\n private:\n // This ECS component layer\n /**\n * Member thread event-based entrance\n */\n bool asyncRunnerCallback(std::string event, GraphWorker* self);\n\n Parameter> graph_specs_;\n Parameter driver_reconnection_times_;\n std::map> segment_runners_;\n std::shared_ptr worker_thread_;\n size_t completed_segment_runner_nums_;\n struct Event {\n static constexpr const char* kInstantiateSegmentRunner = \"kInstantiateSegmentRunner\";\n static constexpr const char* kRegisterWorker = \"kRegisterWorker\";\n static constexpr const char* kCheckWorkComplete = \"kCheckWorkComplete\";\n };\n\n // Communication layer\n Parameter> server_;\n Parameter> client_;\n\n // Service layer\n Parameter initialize_segments_uri_;\n Parameter set_component_params_uri_;\n Parameter activate_segments_uri_;\n Parameter run_segments_uri_;\n Parameter deactivate_segments_uri_;\n Parameter destroy_segments_uri_;\n Parameter stop_worker_uri_;\n\n private:\n // Services to handle request from the GraphDriver\n Expected onInitializeSegments(const std::string& resource, const std::string& payload);\n Expected onSetComponentParams(const std::string& resource, const std::string& payload);\n Expected onActivateSegments(const std::string& resource, const std::string& payload);\n Expected onRunSegments(const std::string& resource, const std::string& payload);\n Expected onDeactivateSegments(const std::string& resource, const std::string& payload);\n Expected onDestroySegments(const std::string& resource, const std::string& payload);\n Expected onStopWorker(const std::string& resource, const std::string& payload);\n\n Expected instantiateSegmentRunners();\n Expected registerGraphWorker();\n Expected checkComplete();\n std::unique_ptr worker_info_;\n\n gxf_result_t stop_all_segments();\n\n // helper methods\n std::string getPrimaryIp();\n Expected createWorkerInfo();\n\n friend class SegmentRunner;\n};\n\n//\n// utils for Parameter>\n//\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(\n gxf_context_t context, gxf_uid_t component_uid, const char* key,\n const YAML::Node& node, const std::string& prefix) {\n if (!node.IsMap() || node.size() < 2) {\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n GraphSpec graph_spec;\n // mandatory fields\n graph_spec.app_path = node[\"app-path\"].as();\n graph_spec.manifest_path = node[\"manifest-path\"].as();\n // optional fields\n if (node[\"param-path\"].IsDefined()) { // Check if \"param-path\" is defined\n graph_spec.param_path = node[\"param-path\"].as();\n } else {\n graph_spec.param_path = \"\";\n }\n if (node[\"severity\"].IsDefined()) {\n graph_spec.severity = node[\"severity\"].as();\n } else {\n graph_spec.severity = 3;\n }\n return graph_spec;\n }\n};\n\ntemplate <>\nstruct ParameterWrapper {\n // Wrap the value to a YAML::Node instance\n static Expected Wrap(\n gxf_context_t context,\n const GraphSpec& value) {\n YAML::Node node;\n // mandatory fields\n node[\"app-path\"] = value.app_path;\n node[\"manifest-path\"] = value.manifest_path;\n // optional fields\n if (!value.param_path.empty()) {\n node[\"param-path\"] = value.param_path;\n }\n if (value.severity >= 0 && value.severity <= 4) {\n node[\"severity\"] = value.severity;\n }\n return node;\n }\n};\n\ntemplate <>\nstruct ParameterParser> {\n static Expected> Parse(\n gxf_context_t context, gxf_uid_t component_uid, const char* key,\n const YAML::Node& node, const std::string& prefix) {\n if (!node.IsMap()) {\n return Unexpected{GXF_PARAMETER_PARSER_ERROR};\n }\n std::map segment_runners;\n for (const auto& p : node) {\n const std::string k = p.first.as();\n const auto maybe = ParameterParser::Parse(\n context, component_uid, k.c_str(), node[k], prefix);\n if (!maybe) {\n return ForwardError(maybe);\n }\n segment_runners[k] = maybe.value();\n }\n return segment_runners;\n }\n};\n\ntemplate <>\nstruct ParameterWrapper> {\n // Wrap the value to a YAML::Node instance\n static Expected Wrap(\n gxf_context_t context,\n const std::map& value) {\n YAML::Node node(YAML::NodeType::Map);\n for (auto &i : value) {\n auto maybe = ParameterWrapper::Wrap(context, i.second);\n if (!maybe) {\n return ForwardError(maybe);\n }\n node[i.first] = maybe.value();\n }\n return node;\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_GRAPH_WORKER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/greedy_scheduler.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_GREEDY_SCHEDULER_HPP_\n#define NVIDIA_GXF_STD_GREEDY_SCHEDULER_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"common/logger.hpp\"\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/clock.hpp\"\n#include \"gxf/std/gems/event_list/event_list.hpp\"\n#include \"gxf/std/scheduler.hpp\"\n#include \"gxf/std/scheduling_condition.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Forward declarations\nclass EntityExecutor;\n\n/// @brief A basic single-threaded scheduler which tests scheduling term greedily\n///\n/// This scheduler is great for simple use cases and predictable execution. It evaluates\n/// scheduling terms greedily and may incur a large overhead of scheduling term execution. Thus it\n/// may not be suitable for large applications.\n///\n/// The scheduler requires a Clock to keep track of time. Based on the choice of clock the scheduler\n/// will execute differently. If a Realtime clock is used the scheduler will execute in realtime.\n/// This means for example pausing execution, i.e. sleeping the thread, until periodic scheduling\n/// terms are due again. If a ManualClock is used scheduling will happen \"time-compressed\". This\n/// means flow of time is altered to execute codelets immediately after each other.\nclass GreedyScheduler : public Scheduler {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n gxf_result_t prepare_abi(EntityExecutor* executor) override;\n gxf_result_t schedule_abi(gxf_uid_t eid) override;\n gxf_result_t unschedule_abi(gxf_uid_t eid) override;\n gxf_result_t runAsync_abi() override;\n gxf_result_t stop_abi() override;\n gxf_result_t wait_abi() override;\n gxf_result_t event_notify_abi(gxf_uid_t eid, gxf_event_t event) override;\n\n private:\n Parameter> clock_;\n Parameter realtime_;\n Parameter max_duration_ms_;\n Parameter stop_on_deadlock_;\n Parameter check_recession_period_ms_;\n Parameter stop_on_deadlock_timeout_;\n\n EntityExecutor* executor_ = nullptr;\n\n std::atomic_bool stopping_{true};\n std::atomic thread_error_code_;\n std::unique_ptr thread_ = nullptr;\n\n // Used temporarily until realtime flag is removed.\n Entity clock_entity_;\n\n // Used for keeping track of async events\n uint64_t count_wait_event_{0};\n std::mutex event_mutex_;\n std::unique_ptr> event_notified_;\n std::unique_ptr> event_waiting_;\n std::condition_variable event_notification_cv_;\n\n // Used for keeping track of graph entities\n FixedVector active_entities_;\n FixedVector new_entities_;\n std::unique_ptr> unschedule_entities_;\n std::mutex entity_mutex_;\n // Dedicated mutex for each entity\n std::unordered_map> entity_mutex_map_;\n\n // latest timestamp from last should_stop == false\n int64_t last_no_stop_ts_ = 0;\n // maintain last no stop timestamp, and check if need to update should_stop\n gxf_result_t stop_on_deadlock_timeout(const int64_t timeout, const int64_t now,\n bool& should_stop);\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_GREEDY_SCHEDULER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/ipc_client.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_GXF_STD_IPC_CLIENT_HPP_\n#define NVIDIA_GXF_GXF_STD_IPC_CLIENT_HPP_\n\n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * interface of client to IPCServer\n*/\nclass IPCClient : public Component {\n public:\n static constexpr const char* kDefaultPingServiceName = \"ping\";\n /**\n * param:\n * rervice: object that implements the query API\n * resource: on which the query is to be performed\n * return: text response that carries the result of a query\n */\n virtual Expected query(const std::string& service,\n const std::string& resource) = 0;\n /**\n * param:\n * service: object that implements the action API\n * resource: on which the action is to be performed\n * data: action data\n * return: indicator of a success or failure\n */\n virtual Expected action(const std::string& service,\n const std::string& resource,\n const std::string& data) = 0;\n virtual Expected\n ping(const std::string& service = kDefaultPingServiceName) = 0;\n virtual IPCClient& changeAddress(const std::string& ip, uint32_t port) = 0;\n\n protected:\n Parameter port_;\n Parameter server_ip_address_;\n std::string toIpPort(const std::string& ip, uint32_t port) {\n return ip + \":\" + std::to_string(port);\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/ipc_server.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_GXF_STD_IPC_SERVER_HPP_\n#define NVIDIA_GXF_GXF_STD_IPC_SERVER_HPP_\n\n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// interface of a request/response based server which accepts requests composed\n// of a list of strings as parameters and returns a text(json) response\nclass IPCServer : public Component {\n public:\n typedef enum {\n kQuery = 0,\n kAction\n } ServiceType;\n\n // service handler for query requests\n // params:\n // resource: on which the query is to be performed\n // return: text response that carries the result of a query\n typedef std::function(const std::string& resource)> QueryHandler;\n\n // service handler for action requests\n // params:\n // resource: on which the action is to be performed\n // data: action data\n // return: indicator of a success or failure\n typedef std::function(const std::string& resource,\n const std::string& data)> ActionHandler;\n\n // callback to handle the request received by the server\n typedef struct {\n std::string name;\n ServiceType type;\n // TODO(chunlinl): use std::variant to wrap the handler once c++17 support is added\n struct {\n QueryHandler query;\n ActionHandler action;\n } handler;\n } Service;\n\n // register a named service on the IPC server to handler requests from remote clients\n virtual Expected registerService(const Service& service) = 0;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/memory_buffer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_MEMORY_BUFFER_HPP_\n#define NVIDIA_GXF_STD_MEMORY_BUFFER_HPP_\n\n#include \n\n#include \"common/byte.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/allocator.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nclass MemoryBuffer {\n public:\n MemoryBuffer() = default;\n MemoryBuffer(const MemoryBuffer&) = delete;\n MemoryBuffer& operator=(const MemoryBuffer&) = delete;\n\n MemoryBuffer(MemoryBuffer&& other) { *this = std::move(other); }\n\n MemoryBuffer& operator=(MemoryBuffer&& other) {\n size_ = other.size_;\n storage_type_ = other.storage_type_;\n pointer_ = other.pointer_;\n release_func_ = std::move(other.release_func_);\n\n other.pointer_ = nullptr;\n other.release_func_ = nullptr;\n\n return *this;\n }\n\n // Type of the callback function to release memory passed to the MemoryBuffer\n // using the wrapMemory method\n using release_function_t = std::function (void* pointer)>;\n\n Expected freeBuffer() {\n if (release_func_ && pointer_) {\n const Expected result = release_func_(pointer_);\n if (!result) { return ForwardError(result); }\n\n release_func_ = nullptr;\n pointer_ = nullptr;\n size_ = 0;\n }\n\n return Success;\n }\n\n virtual ~MemoryBuffer() { freeBuffer(); }\n\n Expected resize(Handle allocator, uint64_t size,\n MemoryStorageType storage_type) {\n const auto result = freeBuffer();\n if (!result) {\n GXF_LOG_ERROR(\"Failed to free memory. Error code: %s\", GxfResultStr(result.error()));\n return ForwardError(result);\n }\n\n const auto maybe = allocator->allocate(size, storage_type);\n if (!maybe) {\n GXF_LOG_ERROR(\"%s Failed to allocate %ld size of memory of type %d. Error code: %s\",\n allocator->name(), size, static_cast(storage_type),\n GxfResultStr(maybe.error()));\n return ForwardError(maybe);\n }\n\n storage_type_ = storage_type;\n pointer_ = maybe.value();\n size_ = size;\n\n release_func_ = [allocator] (void *data) {\n return allocator->free(reinterpret_cast(data));\n };\n\n return Success;\n }\n\n // Wrap existing memory inside the MemoryBuffer. A callback function of type\n // release_function_t may be passed that will be called when the MemoryBuffer\n // wants to release the memory.\n Expected wrapMemory(void* pointer, uint64_t size,\n MemoryStorageType storage_type,\n release_function_t release_func) {\n if (pointer != this->pointer()) {\n const auto result = freeBuffer();\n if (!result) { return ForwardError(result); }\n\n pointer_ = reinterpret_cast(pointer);\n }\n storage_type_ = storage_type;\n size_ = size;\n release_func_ = release_func;\n\n return Success;\n }\n\n // The type of memory where the data is stored.\n MemoryStorageType storage_type() const { return storage_type_; }\n\n // Raw pointer to the first byte of elements stored in the buffer.\n byte* pointer() const { return pointer_; }\n\n // Size of buffer contents in bytes\n uint64_t size() const { return size_; }\n\n protected:\n uint64_t size_ = 0;\n byte* pointer_ = nullptr;\n MemoryStorageType storage_type_ = MemoryStorageType::kHost;\n release_function_t release_func_ = nullptr;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_MEMORY_BUFFER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/metric.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_METRIC_HPP_\n#define NVIDIA_GXF_STD_METRIC_HPP_\n\n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// This component holds data for a single metric, where a metric is any double-typed value that is\n// computed during the execution of a GXF application, and has success criteria defined by a\n// lower threshold, an upper threshold, and an aggregation function that specifies how to\n// aggregate multiple samples into a final value for the metric. Other components in a GXF app can\n// access this component in order to, for example, write the metrics to a file for downstream\n// analysis of app execution.\nclass Metric : public Component {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override { return GXF_SUCCESS; }\n\n // Type for the aggregation functor.\n using aggregation_function_t = std::function;\n\n // Records a single sample to the metric and updates aggregated_value_.\n Expected record(double sample);\n\n // Sets a custom function object to use when computing the aggregated_value_ over a set of\n // samples.\n Expected setAggregationFunction(aggregation_function_t aggregation_function);\n\n // Checks whether the aggregated_value_ lies within the expected range.\n Expected evaluateSuccess();\n\n // Public accessor functions for metric data.\n Expected getAggregatedValue();\n Expected getLowerThreshold();\n Expected getUpperThreshold();\n\n // Public functions to set a few common aggregation functions.\n // Computes the mean of a set of samples.\n Expected setMeanAggregationFunction();\n // Computes the root-mean-square average over a set of samples.\n Expected setRootMeanSquareAggregationFunction();\n // Finds the maximum absolute value over a set of samples.\n Expected setAbsMaxAggregationFunction();\n // Finds the maximum over a set of samples.\n Expected setMaxAggregationFunction();\n // Finds the minimum over a set of samples.\n Expected setMinAggregationFunction();\n // Computes the total sum over a set of samples.\n Expected setSumAggregationFunction();\n // Fixes the aggregated value to the last recorded sample.\n Expected setFixedAggregationFunction();\n\n // Resets the aggregated value to an uninitialized value\n Expected reset();\n\n private:\n Parameter aggregation_policy_;\n Parameter lower_threshold_;\n Parameter upper_threshold_;\n\n // Current aggregated value across all samples recorded to this metric. Updated on record().\n Expected aggregated_value_ = Unexpected{GXF_UNINITIALIZED_VALUE};\n // Function object that is used to update the metric's aggregated value based on a given sample.\n // The function accepts a sample and returns the updated aggregated value. Called on record().\n aggregation_function_t aggregation_function_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_METRIC_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/monitor.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_MONITOR_HPP_\n#define NVIDIA_GXF_STD_MONITOR_HPP_\n\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Interface for monitoring entities during runtime\nclass Monitor : public Component {\n public:\n virtual ~Monitor() = default;\n\n // Callback for after an entity executes\n // eid - ID of entity that finished execution\n // timestamp - execution timestamp\n // code - execution result\n virtual gxf_result_t on_execute_abi(gxf_uid_t eid, uint64_t timestamp, gxf_result_t code) = 0;\n\n // C++ API wrapper\n Expected onExecute(gxf_uid_t eid, uint64_t timestamp, gxf_result_t code);\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_MONITOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/multi_thread_scheduler.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_MUTLI_THREAD_SCHEDULER_HPP_\n#define NVIDIA_GXF_STD_MUTLI_THREAD_SCHEDULER_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/std/clock.hpp\"\n#include \"gxf/std/cpu_thread.hpp\"\n#include \"gxf/std/gems/event_list/event_list.hpp\"\n#include \"gxf/std/gems/staging_queue/staging_queue.hpp\"\n#include \"gxf/std/gems/timed_job_list/timed_job_list.hpp\"\n#include \"gxf/std/scheduler.hpp\"\n#include \"gxf/std/scheduling_condition.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Forward declarations\nclass EntityExecutor;\n\nconstexpr int64_t kMsToNs = 1'000'000l; // Convenient constant of 1 ms = 1e6 ns\nconstexpr int64_t kMaxSlipNs = 1 * kMsToNs; // Max slip tolerance set to 1 ms\n\n/// @brief Multi-threaded scheduler\n///\n/// The scheduler requires a Clock to keep track of time. It spawns a dispatcher thread and several\n/// worker threads as configured. Dispatcher thread checks condition of entities and place them in\n/// worker queue if they are ready to run or have expected time to run.\nclass MultiThreadScheduler : public Scheduler {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n gxf_result_t prepare_abi(EntityExecutor* executor) override;\n gxf_result_t schedule_abi(gxf_uid_t eid) override;\n gxf_result_t unschedule_abi(gxf_uid_t eid) override;\n gxf_result_t runAsync_abi() override;\n gxf_result_t stop_abi() override;\n gxf_result_t wait_abi() override;\n gxf_result_t event_notify_abi(gxf_uid_t eid, gxf_event_t event) override;\n\n private:\n std::atomic workerExecTime { 0 };\n std::atomic workerWaitTime { 0};\n std::atomic workerExecCount { 0 };\n uint64_t dispatcherExecTime = 0;\n uint64_t dispatcherWaitTime = 0;\n uint64_t dispatcherExecCount = 0;\n // Entrance for dispatcher threads\n void dispatcherThreadEntrance();\n // Entrance for async event handler thread\n void asyncEventThreadEntrance();\n // Entrance for worker threads\n void workerThreadEntrance(ThreadPool* pool, int64_t thread_number);\n\n // Checks if need to stop due to no active entities or expiration\n void checkEndingCriteria(int64_t timestamp);\n\n // Updates condition of specific entity id and keep track of how many entities are good to run\n void updateCondition(gxf_uid_t eid, const SchedulingCondition& next_condition);\n\n // stops all async threads and deactivates all the entities\n gxf_result_t stopAllThreads();\n\n // stops all jobs queued in dispatcher and workers\n void stopAllJobs();\n\n // returns the current state of the scheduler as string\n const char* schedulerStateString();\n\n // cache thread info for pinned job into resources_\n void prepareResourceMap(gxf_uid_t eid);\n // cache thread info for every job into resources_, use default thread pool for non-pinned job\n void prepareResourceMapStrict(gxf_uid_t eid);\n // In worker thread, check if pinned job matches the thread\n bool isJobMatch(ThreadPool* pool, int64_t thread_number, gxf_uid_t eid);\n // In worker thread, check if the job matches the thread and if thread matches the job\n bool isJobMatchStrict(ThreadPool* pool, int64_t thread_number, gxf_uid_t eid);\n\n // Parameters\n Parameter> clock_;\n Parameter max_duration_ms_;\n Parameter check_recession_period_ms_;\n Parameter stop_on_deadlock_;\n Parameter stop_on_deadlock_timeout_;\n Parameter worker_thread_number_;\n Parameter thread_pool_allocation_auto_;\n Parameter strict_job_thread_pinning_;\n Parameter worker_thread_name_id_;\n\n EntityExecutor* executor_ = nullptr;\n\n ThreadPool default_thread_pool_;\n\n // thread pool set including default pool and added pools\n std::set thread_pool_set_;\n\n // Resource map for thread pools and worker threads\n std::map> resources_;\n\n gxf_result_t thread_error_code_;\n\n // A thread to dispatch jobs to worker pool\n std::thread dispatcher_thread_;\n\n // Mutex to synchronize dispatcher thread\n std::mutex dispatcher_sync_mutex_;\n\n // instances of dispatcher/worker threads. 0 index would be async event handler thread.\n std::vector async_threads_;\n\n // Keep track of the timestamp that the scheduler started working for checking expiration\n int64_t start_timestamp_ = 0;\n\n // Keep track of conditions for entities\n std::unordered_map conditions_;\n int64_t ready_count_{0};\n int64_t wait_time_count_{0};\n int64_t wait_event_count_{0};\n int64_t wait_count_{0};\n std::mutex conditions_mutex_;\n\n // Queue with execution time for jobs to execute\n std::unique_ptr> worker_jobs_;\n\n // Queue worker threads => dispatcher thread\n std::unique_ptr> check_jobs_;\n\n // synchronize entities\n std::mutex event_notification_mutex_;\n std::unique_ptr> unschedule_entities_;\n\n // Mutex to synchronize worker thread pool\n std::mutex thread_sync_mutex_;\n std::condition_variable thread_sync_cv_;\n\n // Keep track of asynchronous events\n std::unique_ptr> event_notified_;\n std::unique_ptr> event_waiting_;\n std::condition_variable event_notification_cv_;\n\n enum class State {\n kNotStarted = 0, // Scheduler has not started execution yet, starts during runAsync_abi()\n kRunning, // Execution threads are running\n kStopping, // Ending criteria reached, execution threads are doing pending jobs\n kStopped, // Scheduler has stopped\n };\n\n std::atomic state_{State::kNotStarted};\n std::mutex state_change_mutex_;\n std::condition_variable work_done_cv_;\n\n // latest timestamp from last should_stop == false\n int64_t last_no_stop_ts_ = 0;\n // maintain last no stop timestamp, and check if need to update should_stop\n gxf_result_t stop_on_deadlock_timeout(const int64_t timeout,\n const int64_t now, bool& should_stop);\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_MUTLI_THREAD_SCHEDULER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/network_context.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef GXF_STD_NETWORK_CONTEXT_HPP\n#define GXF_STD_NETWORK_CONTEXT_HPP\n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/handle.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nclass NetworkContext : public Component {\n public:\n virtual gxf_result_t init_context() = 0;\n // Finds transmitters and receivers passes the network context to transmitter\n // and receivers and make connection between them\n virtual Expected addRoutes(const Entity& entity) = 0;\n\n // Closes the connection between transmitters and receivers\n virtual Expected removeRoutes(const Entity& entity) = 0;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/new_component_allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_NEW_COMPONENT_ALLOCATOR_HPP\n#define NVIDIA_GXF_STD_NEW_COMPONENT_ALLOCATOR_HPP\n\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/std/component_allocator.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Default implementation for allocating components using new/delete\ntemplate \nclass NewComponentAllocator\n : public ComponentAllocator {\n public:\n ~NewComponentAllocator() override = default;\n\n gxf_result_t allocate_abi(void** out_pointer) override {\n if (out_pointer == nullptr) {\n return GXF_ARGUMENT_NULL;\n }\n *out_pointer = static_cast(new T());\n if (*out_pointer == nullptr) {\n return GXF_OUT_OF_MEMORY;\n }\n return GXF_SUCCESS;\n }\n\n gxf_result_t deallocate_abi(void* pointer) override {\n if (pointer == nullptr) {\n return GXF_ARGUMENT_NULL;\n }\n delete static_cast(pointer);\n return GXF_SUCCESS;\n }\n};\n\n// Special case of standard component allocator for abstract components\ntemplate \nclass NewComponentAllocator::value>>\n : public ComponentAllocator {\n public:\n ~NewComponentAllocator() override = default;\n\n gxf_result_t allocate_abi(void** out_pointer) override {\n return GXF_FACTORY_ABSTRACT_CLASS;\n }\n\n gxf_result_t deallocate_abi(void* pointer) override {\n return GXF_FACTORY_ABSTRACT_CLASS;\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/queue.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 202-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_QUEUE_HPP\n#define NVIDIA_GXF_STD_QUEUE_HPP\n\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Interface for storing entities in a queue\nclass Queue : public Component {\n public:\n virtual ~Queue() = default;\n\n // Gets the next (oldest) entity in the queue.\n virtual gxf_result_t pop_abi(gxf_uid_t* uid) = 0;\n\n // Adds a new entity to the queue. The receiver takes shared\n // ownership of the entity.\n virtual gxf_result_t push_abi(gxf_uid_t other) = 0;\n\n // Peeks the entity at given index on the main stage.\n virtual gxf_result_t peek_abi(gxf_uid_t* uid, int32_t index) = 0;\n\n // The total number of entities the queue can hold.\n virtual size_t capacity_abi() = 0;\n\n // The total number of entities the queue currently holds.\n virtual size_t size_abi() = 0;\n\n Expected pop();\n\n Expected push(const Entity& other);\n\n Expected peek(int32_t index = 0);\n\n size_t capacity();\n\n size_t size();\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/receiver.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_RECEIVER_HPP\n#define NVIDIA_GXF_STD_RECEIVER_HPP\n\n#include \n#include \"gxf/std/queue.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Interface for receiving entities.\nclass Receiver : public Queue {\n public:\n // Receives the next entity from the main stage.\n virtual gxf_result_t receive_abi(gxf_uid_t* uid) = 0;\n\n // The total number of entities which have recently arrived but are not yet on the main stage.\n virtual size_t back_size_abi() = 0;\n\n // Peeks into back stage\n virtual gxf_result_t peek_back_abi(gxf_uid_t* uid, int32_t index) = 0;\n\n // Moves entities which recently arrived to the main stage.\n virtual gxf_result_t sync_abi() = 0;\n\n virtual gxf_result_t sync_io_abi() { return GXF_SUCCESS; }\n\n virtual gxf_result_t wait_abi() { return GXF_SUCCESS; }\n\n Expected receive();\n\n size_t back_size();\n\n Expected sync();\n\n Expected sync_io();\n\n Expected wait();\n\n Expected peekBack(int32_t index = 0);\n\n Expected setTransmitter(Handle tx);\n\n private:\n std::set> connected_transmitters_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/resources.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_RESOURCES_HPP_\n#define NVIDIA_GXF_STD_RESOURCES_HPP_\n\n#include \n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/entity.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// A base type for all kinds of resources.\n// This is used to filter out resource Component from an entity\nclass ResourceBase : public Component {};\n\nclass ThreadPool : public ResourceBase {\n public:\n struct Thread {\n gxf_uid_t uid;\n gxf_uid_t cpu_thread_cid;\n // Scalability: std::thread\n };\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n Expected addThread(gxf_uid_t key, gxf_uid_t cpu_thread_cid = kUnspecifiedUid);\n Expected addThread(gxf_uid_t key, const std::vector& pin_cores);\n const Expected getThread(gxf_uid_t key) const;\n const std::map& get() const;\n int64_t size() const;\n int64_t priority() const;\n\n std::vector coresToPin() const {\n const auto maybe_pin_cores = pin_cores_.try_get();\n if (maybe_pin_cores) {\n return maybe_pin_cores.value();\n }\n return {};\n }\n\n private:\n Parameter initial_size_;\n Parameter priority_;\n // CPU core IDs to pin the worker threads to (empty means no core pinning)\n Parameter> pin_cores_;\n std::map thread_pool_;\n static inline gxf_uid_t next_uid_ = 0;\n};\n\nclass GPUDevice : public ResourceBase {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n int32_t device_id() const { return dev_id_; }\n\n private:\n Parameter dev_id_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_RESOURCES_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduler.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \"gxf/core/gxf.h\"\n#include \"gxf/std/resources.hpp\"\n#include \"gxf/std/system.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nclass EntityExecutor; // forward declaration\n\n// An interface which extends the nvidia::gxf::System interface to create schedulers\n// which can execute codelets.\n\nclass Scheduler : public System {\n public:\n virtual gxf_result_t prepare_abi(EntityExecutor* executor) = 0;\n};\n\n#ifdef __linux__\n\n// glibc before 2.41 does not provide wrappers for sched_setattr() and sched_getattr(),\n// so we need to define them here.\n#ifdef __x86_64__\n#define __NR_sched_setattr 314\n#define __NR_sched_getattr 315\n#endif\n\n#ifdef __aarch64__\n#define __NR_sched_setattr 274\n#define __NR_sched_getattr 275\n#endif\n\nstruct sched_attr {\n uint32_t size;\n uint32_t sched_policy;\n uint64_t sched_flags;\n int32_t sched_nice;\n uint32_t sched_priority;\n uint64_t sched_runtime;\n uint64_t sched_deadline;\n uint64_t sched_period;\n};\n\nstatic inline int\nsched_setattr(pid_t pid, const struct sched_attr* attr, unsigned flags) {\n return syscall(__NR_sched_setattr, pid, attr, flags);\n}\n\nstatic inline int\nsched_getattr(pid_t pid, struct sched_attr* attr,\n unsigned int size, unsigned int flags) {\n return syscall(__NR_sched_getattr, pid, attr, size, flags);\n}\n#endif\n\n} // namespace gxf\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_condition.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_SCHEDULING_CONDITION_HPP\n#define NVIDIA_GXF_STD_SCHEDULING_CONDITION_HPP\n#include \n\nnamespace nvidia {\nnamespace gxf {\n\n// The type of a scheduling condition\nenum class SchedulingConditionType : int32_t {\n // Will never execute again\n NEVER = 0,\n // Ready to execute now\n READY = 1,\n // May execute again at some point in the future\n WAIT = 2,\n // Will execute after a certain known time interval. Negative or zero interval will result in\n // immediate execution.\n WAIT_TIME = 3,\n // Waiting for an event with unknown interval time. Entity will be put in a waiting queue until\n // event done notification is signalled\n WAIT_EVENT = 4,\n};\n\n// A condition for which the scheduling term is waiting.\nstruct SchedulingCondition {\n // Describes the type of the condition\n SchedulingConditionType type;\n // A timestamp needed for certain conditions. Might not be set always.\n int64_t target_timestamp;\n};\n\n// Merges two scheduling conditions with an And-like logic. For example NEVER and READY will result\n// in NEVER.\nSchedulingCondition AndCombine(SchedulingCondition a, SchedulingCondition b);\n\n// Gets a string describing the scheduling type condition\nconst char* SchedulingConditionTypeStr(const SchedulingConditionType& condition_type);\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_SCHEDULING_CONDITION_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_term.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_SCHEDULING_TERM_HPP\n#define NVIDIA_GXF_STD_SCHEDULING_TERM_HPP\n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/std/scheduling_condition.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/// @brief Base class for scheduling terms\n///\n/// Scheduling terms are used by a scheduler to determine if codelets in an entity are ready for\n/// execution.\nclass SchedulingTerm : public Component {\n public:\n virtual ~SchedulingTerm() = default;\n\n // Get the condition on which the scheduling waits before allowing execution. If the term is\n // waiting for a time event 'target_timestamp' will contain the target timestamp.\n virtual gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const = 0;\n\n // Called each time after the entity of this term was executed.\n virtual gxf_result_t onExecute_abi(int64_t dt) = 0;\n\n // Checks if the state of the scheduling term can be updated and updates it\n virtual gxf_result_t update_state_abi(int64_t timestamp) { return GXF_SUCCESS; }\n\n Expected check(int64_t timestamp) {\n SchedulingConditionType status;\n int64_t target_timestamp = 0;\n gxf_result_t result = update_state_abi(timestamp);\n if (result != GXF_SUCCESS) { return Unexpected{result}; }\n const gxf_result_t error = check_abi(timestamp, &status, &target_timestamp);\n return ExpectedOrCode(error, SchedulingCondition{status, target_timestamp});\n }\n\n Expected onExecute(int64_t timestamp) { return ExpectedOrCode(onExecute_abi(timestamp)); }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_term_combiner.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_SCHEDULING_TERM_COMBINER_HPP\n#define NVIDIA_GXF_STD_SCHEDULING_TERM_COMBINER_HPP\n\n#include \n\n#include \n\n#include \"gxf/std/scheduling_term.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n/**\n * @brief Base class for scheduling term combiner\n *\n * scheduling term combiners can be used to create complex execution patterns by interpreting\n * combinations of scheduling terms differently\n */\nclass SchedulingTermCombiner : public Component {\n public:\n // Function to combine two SchedulingCondition types\n virtual SchedulingCondition combine(SchedulingCondition a, SchedulingCondition b) = 0;\n\n // Get the list of scheduling terms in an entity being governed by the combiner\n virtual FixedVector, kMaxComponents> getTermList() const = 0;\n};\n\n/**\n * @brief OR combiners simulate the bitwise OR operation when combining scheduling conditions\n *\n */\nclass OrSchedulingTermCombiner : public SchedulingTermCombiner {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(terms_, \"terms\", \"SchedulingTerms\",\n \"The list of scheduling terms to be combined using OR operation\");\n return GXF_SUCCESS;\n }\n\n SchedulingCondition combine(SchedulingCondition a, SchedulingCondition b) override {\n // \"never\" has the highest significance\n if (a.type == SchedulingConditionType::NEVER || b.type == SchedulingConditionType::NEVER) {\n return {SchedulingConditionType::NEVER, 0};\n }\n\n // If both are ready, choose the max target timestamp\n if (a.type == SchedulingConditionType::READY && b.type == SchedulingConditionType::READY) {\n return {SchedulingConditionType::READY, std::max(a.target_timestamp, b.target_timestamp)};\n }\n\n // Check if either one of them is ready\n if (a.type == SchedulingConditionType::READY) {\n return {SchedulingConditionType::READY, a.target_timestamp};\n } else if (b.type == SchedulingConditionType::READY) {\n return {SchedulingConditionType::READY, b.target_timestamp};\n }\n\n // \"wait event\" has the third highest significance\n if (a.type == SchedulingConditionType::WAIT_EVENT ||\n b.type == SchedulingConditionType::WAIT_EVENT) {\n return {SchedulingConditionType::WAIT_EVENT, 0};\n }\n\n // \"wait time\" events are combined so that the maximum time is returned\n if (a.type == SchedulingConditionType::WAIT_TIME &&\n b.type == SchedulingConditionType::WAIT_TIME) {\n return {SchedulingConditionType::WAIT_TIME, std::max(a.target_timestamp, b.target_timestamp)};\n }\n\n // Check if atleast one of them have a target time\n if (a.type == SchedulingConditionType::WAIT_TIME) {\n return a;\n } else if (b.type == SchedulingConditionType::WAIT_TIME) {\n return b;\n }\n\n // The only remaining case is that both are wait\n return {SchedulingConditionType::WAIT, 0};\n }\n\nFixedVector, kMaxComponents> getTermList() const {\n return terms_;\n}\n\nParameter, kMaxComponents>> terms_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_SCHEDULING_TERM_COMBINER_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_terms.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_SCHEDULING_TERMS_HPP_\n#define NVIDIA_GXF_STD_SCHEDULING_TERMS_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/core/parameter_parser.hpp\"\n#include \"gxf/core/parameter_parser_std.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/clock.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/scheduling_term.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nenum class PeriodicSchedulingPolicy {\n // scheduler will try to \"catch up\" on missed ticks\n // eg. assume recess period of 100ms:\n // tick 0 at 0ms -> next_target_ = 100ms\n // tick 1 at 250ms -> next_target_ = 200ms (next_target_ < timestamp)\n // tick 2 at 255ms -> next_target_ = 300ms (double tick before 300ms)\n kCatchUpMissedTicks,\n // scheduler guarantees recess period will have passed before next tick\n // eg. assume recess period of 100ms:\n // tick 0 at 0ms -> next_target_ = 100ms\n // tick 1 at 101ms -> next_target_ = 201ms\n // tick 2 at 350ms -> next_target_ = 450ms\n kMinTimeBetweenTicks,\n // scheduler will not try to \"catch up\" on missed ticks\n // eg. assume recess period of 100ms:\n // tick 0 at 0ms -> next_target_ = 100ms\n // tick 1 at 250ms -> next_target_ = 300ms (single tick before 300ms)\n // tick 2 at 305ms -> next_target_ = 400ms\n kNoCatchUpMissedTicks\n};\n\n // Custom parameter parser for PeriodicSchedulingPolicy\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n const std::string value = node.as();\n if (strcmp(value.c_str(), \"CatchUpMissedTicks\") == 0) {\n return PeriodicSchedulingPolicy::kCatchUpMissedTicks;\n }\n if (strcmp(value.c_str(), \"MinTimeBetweenTicks\") == 0) {\n return PeriodicSchedulingPolicy::kMinTimeBetweenTicks;\n }\n if (strcmp(value.c_str(), \"NoCatchUpMissedTicks\") == 0) {\n return PeriodicSchedulingPolicy::kNoCatchUpMissedTicks;\n }\n return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};\n }\n};\n\n// Custom parameter wrapper for PeriodicSchedulingPolicy\ntemplate<>\nstruct ParameterWrapper {\n static Expected Wrap(gxf_context_t context, const PeriodicSchedulingPolicy& value) {\n YAML::Node node(YAML::NodeType::Scalar);\n switch (value) {\n case PeriodicSchedulingPolicy::kCatchUpMissedTicks: {\n node = std::string(\"CatchUpMissedTicks\");\n break;\n }\n case PeriodicSchedulingPolicy::kMinTimeBetweenTicks: {\n node = std::string(\"MinTimeBetweenTicks\");\n break;\n }\n case PeriodicSchedulingPolicy::kNoCatchUpMissedTicks: {\n node = std::string(\"NoCatchUpMissedTicks\");\n break;\n }\n default:\n return Unexpected{GXF_PARAMETER_OUT_OF_RANGE};\n }\n return node;\n }\n};\n\n// A scheduling term which permits execution only after a minimum time period has passed since the\n// last execution.\nclass PeriodicSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n\n // Minimum time which needs to elapse between two executions (in nano seconds).\n int64_t recess_period_ns() const { return recess_period_ns_; }\n\n // Get the last run time stamp\n Expected last_run_timestamp() const { return next_target_ - recess_period_ns_; }\n\n private:\n Parameter recess_period_;\n Parameter policy_;\n\n int64_t recess_period_ns_ = 0;\n Expected next_target_ = Unexpected{GXF_UNINITIALIZED_VALUE};\n};\n\n// A scheduling term which permits execution only a limited number of times.\nclass CountSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n private:\n Parameter count_;\n\n // The remaining number of permitted executions.\n int64_t remaining_;\n\n SchedulingConditionType current_state_; // The current state of the scheduling term\n int64_t last_run_timestamp_; // timestamp when the entity was last executed\n};\n\n// A component which specifies that an entity shall be executed if the receiver for a given\n// transmitter can accept new messages.\nclass DownstreamReceptiveSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n // The transmitter which needs to be able to publish a message.\n Handle transmitter() const { return transmitter_.get(); }\n // The receiver which is connected to the transmitter and which needs to have room for messages.\n void setReceivers(std::set> receivers) { receivers_ = std::move(receivers); }\n\n // Set the transmitter parameter\n Expected setTransmitter(Handle value) {\n return transmitter_.set(value);\n }\n // Set the min_size parameter\n Expected setMinSize(uint64_t value) {\n return min_size_.set(value);\n }\n\n private:\n Parameter> transmitter_;\n Parameter min_size_;\n\n std::set> receivers_; // The receiver connected to the transmitter (if any).\n SchedulingConditionType current_state_; // The current state of the scheduling term\n int64_t last_state_change_; // timestamp when the state changed the last time\n};\n\n// A scheduling term which permits execution at a user-specified timestamp. The timestamp is\n// specified on the clock provided.\nclass TargetTimeSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n\n // Needs to be called to determine how long to wait for the next execution. If it is not called,\n // the scheduling condition will stay as WAIT.\n gxf_result_t setNextTargetTime(int64_t target_timestamp);\n\n private:\n Parameter> clock_;\n\n // The timestamp at which the most recent execution cycle began\n int64_t last_timestamp_;\n // The timestamp at which the next execution cycle is requested to begin\n mutable Expected target_timestamp_ = Unexpected{GXF_UNINITIALIZED_VALUE};\n // The timestamp at which the next execution cycle is locked to begin\n mutable Expected locked_target_timestamp_ = Unexpected{GXF_UNINITIALIZED_VALUE};\n};\n\n// A component which specifies that an entity shall be executed when a queue has at least a certain\n// number of elements.\nclass MessageAvailableSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n // Set the receiver parameter\n Expected setReceiver(Handle value) {\n return receiver_.set(value);\n }\n // Set the min_size parameter\n Expected setMinSize(size_t value) {\n return min_size_.set(value);\n }\n // Set the front_stage_max_size parameter\n Expected setFrontStageMaxSize(size_t value) {\n return front_stage_max_size_.set(value);\n }\n\n private:\n // Returns true if the condition imposed by min_size is true.\n bool checkMinSize() const;\n\n // Returns true if the condition imposed by front_stage_max_size is true.\n bool checkFrontStageMaxSize() const;\n\n Parameter> receiver_;\n Parameter min_size_;\n Parameter front_stage_max_size_;\n SchedulingConditionType current_state_; // The current state of the scheduling term\n int64_t last_state_change_; // timestamp when the state changed the last time\n};\n\n// Type of sampling to be used for incoming messages\nenum struct SamplingMode {\n kSumOfAll = 0, // Min size specified is for the sum of all messages at all receivers;\n kPerReceiver = 1, // Min size specified is per receiver connected;\n};\n\n// Custom parameter parser for SamplingMode\ntemplate <>\nstruct ParameterParser {\n static Expected Parse(gxf_context_t context, gxf_uid_t component_uid,\n const char* key, const YAML::Node& node,\n const std::string& prefix) {\n const std::string value = node.as();\n if (strcmp(value.c_str(), \"SumOfAll\") == 0) {\n return SamplingMode::kSumOfAll;\n }\n if (strcmp(value.c_str(), \"PerReceiver\") == 0) {\n return SamplingMode::kPerReceiver;\n }\n return Unexpected{GXF_ARGUMENT_OUT_OF_RANGE};\n }\n};\n\n// Custom parameter wrapper for SamplingMode\ntemplate<>\nstruct ParameterWrapper {\n static Expected Wrap(gxf_context_t context, const SamplingMode& value) {\n YAML::Node node(YAML::NodeType::Scalar);\n switch (value) {\n case SamplingMode::kSumOfAll: {\n node = std::string(\"SumOfAll\");\n break;\n }\n case SamplingMode::kPerReceiver: {\n node = std::string(\"PerReceiver\");\n break;\n }\n default:\n return Unexpected{GXF_PARAMETER_OUT_OF_RANGE};\n }\n return node;\n }\n};\n\n\n// A scheduling term which specifies that an entity can be executed when a list of provided input\n// channels combined have at least a given number of messages.\nclass MultiMessageAvailableSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n // Set the min_size parameter\n Expected setMinSize(size_t value) {\n return min_size_.set(value);\n }\n // Set the min_sum parameter\n Expected setMinSum(size_t value) {\n return min_sum_.set(value);\n }\n // Set the sampling_mode parameter\n Expected setSamplingMode(SamplingMode value) {\n return sampling_mode_.set(value);\n }\n // Add a value to receivers parameter\n Expected addReceiver(Handle value) {\n auto rxs = receivers_.get();\n auto result = rxs.push_back(value);\n if (!result) { return Unexpected(GXF_OUT_OF_MEMORY); }\n return receivers_.set(rxs);\n }\n // Add a value to min_sizes parameter\n Expected addMinSize(size_t value) {\n auto min_sizes = min_sizes_.get();\n auto result = min_sizes.push_back(value);\n if (!result) { return Unexpected(GXF_OUT_OF_MEMORY); }\n return min_sizes_.set(min_sizes);\n }\n\n private:\n Parameter, kMaxComponents>> receivers_;\n Parameter min_size_;\n Parameter min_sum_;\n SchedulingConditionType current_state_; // The current state of the scheduling term\n int64_t last_state_change_; // timestamp when the state changed the last time\n Parameter> min_sizes_;\n Parameter sampling_mode_;\n};\n\n// A scheduling term which tries to wait for specified number of messages in receiver.\n// When the first message in the queue mature after specified delay since arrival it would fire\n// regardless.\nclass ExpiringMessageAvailableSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n\n private:\n Parameter max_batch_size_;\n Parameter max_delay_ns_;\n Parameter> receiver_; // The receiver to check\n Parameter> clock_;\n};\n\n// A scheduling term which acts as a boolean AND term to control execution of the\n// entity\nclass BooleanSchedulingTerm : public SchedulingTerm {\n public:\n // Enable entity execution\n Expected enable_tick();\n // Disable entity execution\n Expected disable_tick();\n // Returns true if the tick is enabled.\n bool checkTickEnabled() const;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t dt) override;\n\n private:\n Parameter enable_tick_;\n};\n\n// A Behavior Tree (BT) scheduling term which is referenced by the BT entity\n// itself and the entity's parent (if any) used to schedule the entity itself or\n// its child entities (if any) in BT\nclass BTSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t dt) override;\n // called by the entity's codelet (start/stop the entity itself) or the parent\n // entity's codelet (start/stop the child) in BT\n gxf_result_t set_condition(SchedulingConditionType type);\n\n private:\n Parameter is_root_;\n SchedulingConditionType scheduling_condition_type_{SchedulingConditionType::READY};\n};\n\nenum class AsynchronousEventState {\n READY = 0, // Init state, first tick is pending\n WAIT, // Request to async service yet to be sent, nothing to do but wait\n EVENT_WAITING, // Request sent to an async service, pending event done notification\n EVENT_DONE, // Event done notification received, entity ready to be ticked\n EVENT_NEVER, // Entity does not want to be ticked again, end of execution\n};\n\n// A scheduling term which waits on an asynchronous event from the codelet which can happen outside\n// of the regular tick function.\nclass AsynchronousSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t dt) override;\n void setEventState(AsynchronousEventState state);\n AsynchronousEventState getEventState() const;\n\n private:\n AsynchronousEventState event_state_{AsynchronousEventState::READY};\n mutable std::mutex event_state_mutex_;\n};\n\n// A scheduling term which lets an entity maintain a specific execution (min) frequency\n// The scheduling term will also monitor messages incoming via multiple receivers and\n// switch to READY state if any messages are available\nclass MessageAvailableFrequencyThrottler : public SchedulingTerm {\n public:\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t timestamp) override;\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n private:\n Expected last_run_timestamp_ = Unexpected{GXF_UNINITIALIZED_VALUE};\n Parameter execution_frequency_text_;\n Parameter, kMaxComponents>> receivers_;\n Parameter min_sum_;\n Parameter> min_sizes_;\n Parameter sampling_mode_;\n int64_t message_recess_period_;\n int64_t execution_frequency_;\n\n SchedulingConditionType current_state_; // The current state of the scheduling term\n int64_t last_state_change_; // timestamp when the state changed the last time\n};\n\n// A scheduling term which waits until a given number of blocks are\n// available in a pool. This can be used to force a codelet to wait\n// until a minimum number of its in-flight buffers have returned from\n// downstream consumers.\nclass MemoryAvailableSchedulingTerm : public SchedulingTerm {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t check_abi(int64_t timestamp, SchedulingConditionType* type,\n int64_t* target_timestamp) const override;\n gxf_result_t onExecute_abi(int64_t dt) override;\n gxf_result_t update_state_abi(int64_t timestamp) override;\n\n private:\n bool is_available() const;\n\n Parameter> allocator_;\n Parameter min_bytes_parameter_;\n Parameter min_blocks_parameter_;\n\n // actual minimum number of bytes, computed from parameters\n uint64_t min_bytes_;\n\n SchedulingConditionType current_state_; // The current state of the scheduling term\n int64_t last_state_change_; // timestamp when the state changed the last time\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_SCHEDULING_TERMS_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/system.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_CORE_SYSTEM_HPP\n#define NVIDIA_GXF_CORE_SYSTEM_HPP\n\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Component interface for systems which are run as part of the application run cycle.\nclass System : public Component {\n public:\n virtual ~System() = default;\n\n virtual gxf_result_t schedule_abi(gxf_uid_t eid) = 0;\n virtual gxf_result_t unschedule_abi(gxf_uid_t eid) = 0;\n virtual gxf_result_t runAsync_abi() = 0;\n virtual gxf_result_t stop_abi() = 0;\n virtual gxf_result_t wait_abi() = 0;\n virtual gxf_result_t event_notify_abi(gxf_uid_t eid, gxf_event_t event) = 0;\n\n Expected schedule(const Entity& entity);\n Expected unschedule(const Entity& entity);\n Expected runAsync();\n Expected stop();\n Expected wait();\n Expected event_notify(gxf_uid_t eid, gxf_event_t event);\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/tensor.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/byte.hpp\"\n#include \"dlpack/dlpack.h\"\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/complex.hpp\"\n#include \"gxf/std/dlpack_utils.hpp\"\n#include \"gxf/std/memory_buffer.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Type of parameters and other primitives\nenum class PrimitiveType : int32_t {\n kCustom,\n kInt8,\n kUnsigned8,\n kInt16,\n kUnsigned16,\n kInt32,\n kUnsigned32,\n kInt64,\n kUnsigned64,\n kFloat32,\n kFloat64,\n kComplex64,\n kComplex128,\n kFloat16,\n};\n\n// Returns the size of each element of specific PrimitiveType as number of bytes.\n// Returns 0 for kCustom.\nuint64_t PrimitiveTypeSize(PrimitiveType primitive);\n\ntemplate \nstruct PrimitiveTypeTraits;\n\n#define GXF_PRIMITIVE_TYPE_TRAITS(TYPE, ENUM) \\\n template <> struct PrimitiveTypeTraits { \\\n static constexpr PrimitiveType value = PrimitiveType::ENUM; \\\n static constexpr size_t size = sizeof(TYPE); \\\n }; \\\n\nGXF_PRIMITIVE_TYPE_TRAITS(int8_t, kInt8);\nGXF_PRIMITIVE_TYPE_TRAITS(uint8_t, kUnsigned8);\nGXF_PRIMITIVE_TYPE_TRAITS(int16_t, kInt16);\nGXF_PRIMITIVE_TYPE_TRAITS(uint16_t, kUnsigned16);\nGXF_PRIMITIVE_TYPE_TRAITS(int32_t, kInt32);\nGXF_PRIMITIVE_TYPE_TRAITS(uint32_t, kUnsigned32);\nGXF_PRIMITIVE_TYPE_TRAITS(int64_t, kInt64);\nGXF_PRIMITIVE_TYPE_TRAITS(uint64_t, kUnsigned64);\nGXF_PRIMITIVE_TYPE_TRAITS(__half, kFloat16);\nGXF_PRIMITIVE_TYPE_TRAITS(float, kFloat32);\nGXF_PRIMITIVE_TYPE_TRAITS(double, kFloat64);\nGXF_PRIMITIVE_TYPE_TRAITS(complex64, kComplex64);\nGXF_PRIMITIVE_TYPE_TRAITS(complex128, kComplex128);\n\n// Type to hold the shape of a tensor\nclass Shape {\n public:\n // The maximum possible rank of the tensor.\n static constexpr uint32_t kMaxRank = 8;\n\n // Initializes an empty rank-0 tensor.\n Shape() : rank_(0) {}\n\n // Initializes a shape object with the given dimensions.\n Shape(std::initializer_list dimensions)\n : rank_(0) {\n for (int32_t dimension : dimensions) {\n if (rank_ == kMaxRank) {\n return;\n }\n dimensions_[rank_++] = dimension;\n }\n }\n\n // Creates shape from vector\n Shape(const std::vector& dimensions)\n : rank_(0) {\n for (int32_t dimension : dimensions) {\n if (rank_ == kMaxRank) {\n return;\n }\n dimensions_[rank_++] = dimension;\n }\n }\n\n // Creates shape from array\n Shape(const std::array& dims, uint32_t rank)\n : rank_(rank), dimensions_(dims) {\n }\n\n // Creates shape from array with correct rank\n template \n Shape(const std::array& dims) : rank_(N) {\n static_assert(N < kMaxRank, \"Invalid rank\");\n for (size_t i = 0; i < N; i++) {\n dimensions_[i] = dims[i];\n }\n }\n\n // The rank of the tensor\n uint32_t rank() const { return rank_; }\n\n // The total number of elements in the tensor. Note: this is not the same as the number of bytes\n // required in memory.\n uint64_t size() const {\n uint64_t element_count = 1;\n for (size_t i = 0; i < rank_; i++) {\n element_count *= dimensions_[i];\n }\n return rank_ == 0 ? 0 : element_count;\n }\n\n // Gets the i-th dimension of the tensor.\n // Special cases:\n // If the rank is 0 the function always returns 0.\n // If 'index' is greater or equal than the rank the function returns 1.\n int32_t dimension(uint32_t index) const {\n if (rank_ == 0) {\n return 0;\n } else if (index >= rank_) {\n return 1;\n } else {\n return dimensions_[index];\n }\n }\n\n bool operator== (const Shape& other) const {\n if (rank_ != other.rank_) { return false; }\n for (uint32_t i = 0; i < rank_; ++i) {\n if (dimensions_[i] != other.dimensions_[i]) { return false; }\n }\n return true;\n }\n\n bool operator!= (const Shape& other) const {\n return !(*this == other);\n }\n\n // Check whether shape is valid\n bool valid() const {\n for (uint32_t i = 0; i < rank_; ++i) {\n if (dimensions_[i] <= 0) { return false; }\n }\n return true;\n }\n\n private:\n uint32_t rank_ = 0;\n std::array dimensions_;\n};\n\n/**\n * @brief Class that wraps a DLManagedTensor with a memory data reference.\n *\n * This class is used to wrap a DLManagedTensor (`tensor`) with a shared pointer to the memory\n * data (`memory_ref`). This class also holds shape and strides data in the integer type needed by\n * the DLTensor object since this does not exist as contiguous int64_t on the Tensor object\n * itself. It should also be noted that DLPack `dl_strides` stored here are in number of elements\n * while those returned by `Tensor::stride` are in bytes rather than elements.\n *\n * The DLPack protocol is designed so that the producer (GXF in the case of `toDLPack` or\n * `toDLManagedTensorContext`) continues to own the data. When the borrowing framework no longer\n * needs the tensor, it should call the deleter to notify the producer that the resource is no\n * longer needed.\n *\n * See: https://dmlc.github.io/dlpack/latest/c_api.html#_CPPv415DLManagedTensor\n */\nstruct DLManagedTensorContext {\n DLManagedTensor tensor; ///< The DLManagedTensor to wrap.\n std::shared_ptr memory_ref; ///< The memory data reference.\n\n std::vector dl_shape; ///< Shape of the DLTensor.\n std::vector dl_strides; ///< Strides of the DLTensor.\n};\n\n/**\n * @brief Class to wrap the deleter of a DLManagedTensor.\n *\n * This class is used with DLManagedTensorContext class to wrap the DLManagedTensor.\n *\n * A shared pointer to this class in DLManagedTensorContext class is used as the deleter of the\n * DLManagedTensorContext::memory_ref.\n *\n * When the last reference to the DLManagedTensorContext object is released,\n * DLManagedTensorContext::memory_ref will also be destroyed, which will call the deleter function\n * of the DLManagedTensor object. This allows setting release_func to nullptr when calling\n * wrapTensor within fromDLPack.\n *\n */\nclass DLManagedMemoryBuffer {\n public:\n explicit DLManagedMemoryBuffer(DLManagedTensor* self);\n ~DLManagedMemoryBuffer();\n\n private:\n DLManagedTensor* self_ = nullptr;\n};\n\n// A component which holds a single tensor. Multiple tensors can be added to one\n// entity to create a map of tensors. The component name can be used as key.\nclass Tensor {\n public:\n typedef std::array stride_array_t;\n\n Tensor() = default;\n\n ~Tensor() {\n memory_buffer_.freeBuffer(); // FIXME(V2) error code?\n dl_ctx_.reset();\n element_count_ = 0;\n shape_ = Shape();\n }\n\n Tensor(const Tensor&) = delete;\n\n Tensor(Tensor&& other) {\n *this = std::move(other);\n }\n\n // zero-copy initialization from an existing DLPack DLManagedTensor (C API struct)\n explicit Tensor(const DLManagedTensor* dl_managed_tensor_ptr);\n\n // zero-copy initialization from an existing DLManagedTensorContext (C++-style DLPack wrapper)\n explicit Tensor(std::shared_ptr dl_ctx);\n\n Tensor& operator=(const Tensor&) = delete;\n\n Tensor& operator=(Tensor&& other) {\n shape_ = other.shape_;\n element_count_ = other.element_count_;\n element_type_ = other.element_type_;\n bytes_per_element_ = other.bytes_per_element_;\n strides_ = std::move(other.strides_);\n memory_buffer_ = std::move(other.memory_buffer_);\n dl_ctx_ = std::move(other.dl_ctx_);\n\n return *this;\n }\n\n // The type of memory where the tensor data is stored.\n MemoryStorageType storage_type() const { return memory_buffer_.storage_type(); }\n\n // The shape of the dimensions holds the rank and the dimensions.\n const Shape& shape() const { return shape_; }\n\n // The rank of the tensor.\n uint32_t rank() const { return shape_.rank(); }\n\n // The scalar type of elements stored in the tensor\n PrimitiveType element_type() const { return element_type_; }\n\n // Number of bytes stored per element\n uint64_t bytes_per_element() const { return bytes_per_element_; }\n\n // Total number of elements stored in the tensor.\n uint64_t element_count() const { return element_count_; }\n\n // Size of tensor contents in bytes\n size_t size() const { return memory_buffer_.size(); }\n\n // Raw pointer to the first byte of elements stored in the tensor.\n byte* pointer() const { return memory_buffer_.pointer(); }\n\n // Move the memory buffer\n MemoryBuffer move_buffer() { return std::move(memory_buffer_); }\n\n // Gets a pointer to the first element stored in this tensor. Requested type must match the\n // tensor element type.\n template \n Expected data() {\n if (element_type_ != PrimitiveType::kCustom && PrimitiveTypeTraits::value != element_type_) {\n return Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n return reinterpret_cast(memory_buffer_.pointer());\n }\n\n // Gets a pointer to the first element stored in this tensor. Requested type must match the\n // tensor element type.\n template \n Expected data() const {\n if (element_type_ != PrimitiveType::kCustom && PrimitiveTypeTraits::value != element_type_) {\n return Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n return reinterpret_cast(memory_buffer_.pointer());\n }\n\n // Changes the shape and type of the tensor. Uses a primitive type and dense memory layot.\n // Memory will be allocated with the given allocator.\n template \n Expected reshape(const Shape& shape, MemoryStorageType storage_type,\n Handle allocator) {\n return reshapeCustom(shape, PrimitiveTypeTraits::value, PrimitiveTypeTraits::size,\n Unexpected{GXF_UNINITIALIZED_VALUE}, storage_type, allocator);\n }\n // Changes the shape and type of the tensor. Memory will be allocated with the given allocator\n // strides: The number of bytes that each slide takes for each dimension (alignment).\n // Use ComputeStrides() to calculate it.\n Expected reshapeCustom(const Shape& shape,\n PrimitiveType element_type, uint64_t bytes_per_element,\n Expected strides,\n MemoryStorageType storage_type, Handle allocator);\n\n // Type of the callback function to release memory passed to the tensor using the\n // wrapMemory method\n using release_function_t = MemoryBuffer::release_function_t;\n\n // Wrap existing memory inside the tensor. A callback function of type release_function_t\n // may be passed that will be called when the Tensor wants to release the memory.\n Expected wrapMemory(const Shape& shape,\n PrimitiveType element_type, uint64_t bytes_per_element,\n Expected strides,\n MemoryStorageType storage_type, void* pointer,\n release_function_t release_func, bool reset_dlpack = true);\n\n // Wraps an existing memory buffer element into the current tensor\n Expected wrapMemoryBuffer(const Shape& shape,\n PrimitiveType element_type, uint64_t bytes_per_element,\n Expected strides,\n MemoryBuffer memory_buffer);\n\n // Permute the axes of a tensor.\n // Number of axes must match rank of tensor.\n // Note that since no data is moved, permuting a tensor can be\n // detrimental to performance (data not accessed from the same cache line).\n Expected permute(const std::initializer_list& axes);\n\n // Attempts to reshape the array in memory by modifying the strides\n // Assumes tensor data is stored in row-major order.\n // The product of the element of the new shape must equal the product\n // of the tensor's dimensions\n // Adapted from Numpy:\n // https://github.com/numpy/numpy/blob/45bc13e6d922690eea43b9d807d476e0f243f836/\n // numpy/core/src/multiarray/shape.c#L371\n Expected noCopyReshape(const std::initializer_list& new_shape);\n\n // Insert singleton dimension at specified dimension\n Expected insertSingletonDim(uint32_t dimension);\n\n // Is tensor memory access contiguous?\n Expected isContiguous();\n\n // The size of data in bytes\n uint64_t bytes_size() {\n return shape_.dimension(0) * strides_[0];\n }\n\n // The stride of specified rank in bytes\n uint64_t stride(uint32_t index) const {\n if (index >= shape_.rank()) {\n return 0;\n }\n return strides_[index];\n }\n\n // Get a new DLManagedTensor* corresponding to the Tensor data.\n // An alternative is to use toDLManagedTensorContext instead which returns a shared pointer\n // that will automatically clean up resources once its reference count goes to zero.\n Expected toDLPack();\n\n /**\n * @brief Get the internal DLManagedTensorContext of the Tensor.\n *\n * @return A shared pointer to the Tensor's DLManagedTensorContext.\n */\n Expected&> toDLManagedTensorContext() {\n if (dl_ctx_ == nullptr) {\n auto status = initializeDLContext();\n if (!status) {\n GXF_LOG_ERROR(\n \"Failed to initialize DLManagedTensorContext with code: %s, returning nullptr\",\n GxfResultStr(status.error()));\n ForwardError(status);\n }\n }\n return dl_ctx_;\n }\n\n // Wrap an existing DLPack managed tensor as a Tensor.\n Expected fromDLPack(const DLManagedTensor* dl_managed_tensor_ptr);\n\n // Wrap an existing shared C++ DLManagedTensorContext as a Tensor.\n Expected fromDLPack(std::shared_ptr dl_ctx);\n\n protected:\n // This member will be populated when memory_buffer_ is initialized or updated, allowing it to\n // be used to provide the DLPack interface.\n std::shared_ptr dl_ctx_; ///< The DLManagedTensorContext object.\n\n private:\n Shape shape_;\n uint64_t element_count_ = 0;\n PrimitiveType element_type_ = PrimitiveType::kUnsigned8;\n uint64_t bytes_per_element_ = 1;\n stride_array_t strides_;\n MemoryBuffer memory_buffer_;\n\n /**\n * @brief Get DLDevice object from the GXF Tensor.\n *\n * @return DLDevice object.\n */\n Expected device() const;\n\n // populate DLPack data structures corresponding to the current Tensor\n Expected initializeDLContext();\n\n // If dl_ctx_ has already been initialized, reset it and initialize a new one\n Expected updateDLContext();\n\n // call wrapTensor using data from an existing DLManagedTensor\n Expected wrapDLPack(const DLManagedTensor* dl_managed_tensor_ptr,\n MemoryBuffer::release_function_t release_func = nullptr);\n};\n\n// Helper function to compute strides from Tensor shape, element size and non-trivial\n// alignment step size for row dimension.\n// The third rank from the end is assumed to be the row dimension.\nExpected ComputeRowStrides(const Shape& shape, uint32_t row_step_size,\n const uint32_t bytes_per_element);\n\n// Helper function to compute trivial strides from Tensor shape and element size\nTensor::stride_array_t ComputeTrivialStrides(const Shape& shape, const uint32_t bytes_per_element);\n\n// Helper function to compute strides from steps (minimal number of bytes per slice on each rank)\nTensor::stride_array_t ComputeStrides(const Shape& shape,\n const Tensor::stride_array_t& stride_steps);\n\n// Type to description a tensor used by 'CreateTensorMap'\nstruct TensorDescription {\n std::string name;\n MemoryStorageType storage_type;\n Shape shape;\n PrimitiveType element_type;\n uint64_t bytes_per_element;\n // array providing number of bytes for each slice on each rank\n Expected strides = Unexpected{GXF_UNINITIALIZED_VALUE};\n};\n\n// Creates a new entity with a collection of named tensors\nExpected CreateTensorMap(gxf_context_t context, Handle pool,\n std::initializer_list descriptions,\n bool activate = true);\n\n// Determine tensor shape from a DLTensor struct\nExpected ShapeFromDLTensor(const DLTensor* dl_tensor);\n\n// Determine tensor strides from a DLTensor struct\nExpected StridesFromDLTensor(const DLTensor* dl_tensor);\n\n// Determine the tensor memory storage type from a DLTensor struct\nExpected MemoryStorageTypeFromDLTensor(const DLTensor* dl_tensor);\n\n// Determine the tensor primitive data type from a DLDataType struct\nExpected PrimitiveTypeFromDLDataType(const DLDataType& dtype);\n\n// Convert PrimitiveType to its corresponding DLDataType\nExpected PrimitiveTypeToDLDataType(const PrimitiveType& element_type,\n uint16_t lanes = 1);\n\n} // namespace gxf\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/timestamp.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_TIMESTAMP_HPP\n#define NVIDIA_GXF_STD_TIMESTAMP_HPP\n\n#include \n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Contains timing information for the data in a message. All times are relative to the global GXF\n// clock and in nanoseconds.\nstruct Timestamp {\n // The timestamp in nanoseconds at which the message was published into the system.\n int64_t pubtime;\n // The timestamp in nanoseconds at the message was acquired. This usually refers to the timestamp\n // of the original sensor data which created the message.\n int64_t acqtime;\n};\n\nenum class TimeDomainID : uint8_t {\n // Specifies various sources of timestamp\n TSC = 0,\n NTP,\n PTP,\n TIME_DOMAIN_COUNT // Used to determine the maximum no of timestamp sources available\n};\n\nstatic constexpr ssize_t MAX_TIME_DOMAINS = static_cast(TimeDomainID::TIME_DOMAIN_COUNT);\n\n// Associate timestamp with its source\nusing MultiSourceTimestamp = FixedVector, MAX_TIME_DOMAINS>;\n\n// This function retrieves the timestamp corresponding to the time domain ID\nExpected getTimestamp(MultiSourceTimestamp const& timestamps,\n TimeDomainID const& timeDomainId);\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_TIMESTAMP_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/topic.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_TOPIC_HPP\n#define NVIDIA_GXF_STD_TOPIC_HPP\n\n#include \n#include \n\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Class to add transmitters/receivers to a topic channel.\nclass Topic : public Component {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n\n // Get topic name.\n std::string getTopicName() const {\n return topic_name_.get().empty() ? std::string(name()) : topic_name_;\n }\n\n // Get all transmitters in this topic.\n std::vector> getTransmitters() const { return transmitters_.get(); }\n\n // Get all receivers in this topic.\n std::vector> getReceivers() const { return receivers_.get(); }\n\n private:\n Parameter topic_name_;\n Parameter>> receivers_;\n Parameter>> transmitters_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/transmitter.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_TRANSMITTER_HPP\n#define NVIDIA_GXF_STD_TRANSMITTER_HPP\n\n#include \"gxf/std/queue.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Interface for publishing entities.\nclass Transmitter : public Queue {\n public:\n // Publishes an entity\n virtual gxf_result_t publish_abi(gxf_uid_t uid) = 0;\n\n // The total number of entities which have previously been published and were moved out of the\n // main stage.\n virtual size_t back_size_abi() = 0;\n\n // Moves entities which were published recently out of the main stage.\n virtual gxf_result_t sync_abi() = 0;\n\n virtual gxf_result_t sync_io_abi() { return GXF_SUCCESS; }\n\n virtual gxf_result_t pop_io_abi(gxf_uid_t* uid) { return GXF_NOT_IMPLEMENTED; }\n\n Expected publish(const Entity& other);\n\n Expected publish(Entity& other, const int64_t acq_timestamp);\n\n size_t back_size();\n\n Expected sync();\n\n Expected sync_io();\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/unbounded_allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_STD_UNBOUNDED_ALLOCATOR_HPP_\n#define NVIDIA_GXF_STD_UNBOUNDED_ALLOCATOR_HPP_\n\n#include \n#include \n\n#include \"gxf/std/allocator.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// An allocator which uses cudaMalloc/cudaMallocHost dynamically without a pool. Does not provide\n// bounded execution times.\nclass UnboundedAllocator : public Allocator {\n public:\n UnboundedAllocator() = default;\n ~UnboundedAllocator() = default;\n\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n\n gxf_result_t is_available_abi(uint64_t size) override;\n gxf_result_t allocate_abi(uint64_t size, int32_t storage_type, void** pointer) override;\n gxf_result_t free_abi(void* pointer) override;\n\n private:\n // Mutex to protect cuda_blocks_\n std::mutex mutex_;\n // Remember the blocks so that we know how to delete them\n std::set cuda_blocks_;\n std::set cuda_host_blocks_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_UNBOUNDED_ALLOCATOR_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/vault.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_VAULT_HPP_\n#define NVIDIA_GXF_STD_VAULT_HPP_\n\n#include \n#include \n#include \n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Receives messages, stores them and provides thread-safe access to them.\nclass Vault : public Codelet {\n public:\n using CallbackType = std::function;\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t start() override;\n gxf_result_t tick() override;\n gxf_result_t deinitialize() override;\n\n gxf_result_t setCallback(CallbackType callback);\n\n // Waits until at least the given number of entities have arrived, stores them in the vault,\n // and returns their UIDs.\n std::vector storeBlocking(size_t count);\n\n // Waits until at least the given number of entities have arrived, stores them in the vault,\n // and returns their UIDs or times out within a targeted duration (nanoseconds).\n std::vector storeBlockingFor(size_t count, int64_t duration_ns);\n\n // Tries to grab at most specified number of entities and return without waiting.\n std::vector store(size_t max_count);\n\n // Removes the given entities from the vault\n void free(const std::vector& entities);\n\n private:\n // Stores entities assuming lock\n std::vector storeImpl(size_t max_count);\n\n Parameter> source_;\n Parameter max_waiting_count_;\n Parameter drop_waiting_;\n Parameter callback_address_;\n Parameter enable_callback_;\n\n std::vector entities_waiting_;\n std::vector entities_in_vault_;\n\n std::mutex mutex_;\n std::condition_variable condition_variable_;\n bool alive_;\n std::unique_ptr callback_{ nullptr };\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/std/yaml_file_loader.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STD_YAML_FILE_LOADER_HPP_\n#define NVIDIA_GXF_STD_YAML_FILE_LOADER_HPP_\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"common/yaml_parser.hpp\"\n#include \"gxf/core/entity.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"yaml-cpp/yaml.h\"\n\nnamespace YAML { class Node; }\n\nnamespace nvidia {\nnamespace gxf {\n\nclass ParameterStorage;\n\n// Loads a GXF file and creates entities\n// Components will be initialized in the order they are specified in the YAML file and\n// deinitialized in reverse-initialization order\nclass YamlFileLoader {\n public:\n // Sets the mandatory parameter storage where parameters loaded from YAML are stored.\n void setParameterStorage(std::shared_ptr parameter_storage) {\n parameter_storage_ = parameter_storage;\n }\n\n void setFileRoot(const std::string& root) { root_ = root; }\n\n // Load GXF Graph from file.\n Expected loadFromFile(gxf_context_t context, const std::string& filename,\n const std::string& entity_prefix,\n const char* parameters_override_string[],\n const uint32_t num_overrides, gxf_uid_t parent_eid = kNullUid,\n const YAML::Node& prerequisites = YAML::Node(YAML::NodeType::Null));\n\n // Load GXF Graph from string.\n Expected loadFromString(gxf_context_t context, const std::string& text,\n const std::string& entity_prefix,\n const char* parameters_override_string[],\n const uint32_t num_overrides);\n\n // Load GXF Graph from parsed YAML graph.\n Expected load(gxf_context_t context, const FixedVectorBase& nodes,\n std::string entity_prefix, gxf_uid_t parent_eid,\n const char* parameters_override_string[],\n const uint32_t num_overrides,\n const YAML::Node& prerequisites);\n\n // Save GXF Graph to YAML file.\n Expected saveToFile(gxf_context_t context, const std::string& filename);\n\n private:\n // Finds existing entity or creates a new one\n Expected findOrCreateEntity(\n gxf_context_t context, const Expected& entity_name);\n\n // Creates a new component in an entity by typename\n Expected addComponent(gxf_context_t context, gxf_uid_t eid, const char* type);\n\n // Finds a component in an entity by name\n Expected findComponent(gxf_context_t context, gxf_uid_t eid, const char* name);\n\n // Sets the parameters of a component\n Expected setParameters(gxf_context_t context, gxf_uid_t handle,\n const std::string& prefix, const YAML::Node& parameters);\n\n // Add a component to an entity's interface mapping\n Expected addComponentToInterface(gxf_context_t context, gxf_uid_t eid,\n const std::string& entity_prefix,\n const std::string& interface_name,\n const std::string& tag);\n\n Expected populateEntityGroups(gxf_context_t context,\n const FixedVectorBase& nodes,\n const std::string& entity_prefix);\n\n std::shared_ptr parameter_storage_ = nullptr;\n\n std::string root_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STD_YAML_FILE_LOADER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/stream/stream_nvsci.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STREAM_STREAM_NVSCI_HPP_\n#define NVIDIA_GXF_STREAM_STREAM_NVSCI_HPP_\n\n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/gxf.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\nenum class SyncType {\n GXF_STREAM_SIGNALER_NONE = 0, // Invalid value for signaler\n GXF_STREAM_SIGNALER_CUDA, // Indicates CUDA is the signaler.\n // Used to indicate when some CUDA job is done.\n GXF_STREAM_WAITER_NONE, // Invalid value for waiter\n GXF_STREAM_WAITER_CUDA, // Indicates CUDA is the waiter.\n // Used to wait on some CUDA job to be completed.\n};\n\nstruct Stream : public Component {\n virtual ~Stream() = default;\n\n // Allocates a nvsci sync object.\n virtual gxf_result_t allocate_sync_object(SyncType signalerList,\n SyncType waiterList, void** syncObj) {\n return GXF_NOT_IMPLEMENTED;\n }\n\n // Signal semaphore with cuda stream\n virtual gxf_result_t signalSemaphore() {\n return GXF_NOT_IMPLEMENTED;\n }\n\n // Wait semaphore with cuda stream\n virtual gxf_result_t waitSemaphore() {\n return GXF_NOT_IMPLEMENTED;\n }\n\n // Set cuda stream for the give sync type\n virtual gxf_result_t setCudaStream(SyncType syncType, cudaStream_t stream) {\n return GXF_NOT_IMPLEMENTED;\n }\n\n // Imports the semaphore which will be used for signalling/waiting based on the sync type\n // Streams preserves the semaphore internally and is not exposed to the clients\n virtual gxf_result_t importSemaphore(SyncType syncType) {\n return GXF_NOT_IMPLEMENTED;\n }\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STREAM_STREAM_NVSCI_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/stream/stream_nvscisync.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STREAM_STREAM_NVSCISYNC_HPP_\n#define NVIDIA_GXF_STREAM_STREAM_NVSCISYNC_HPP_\n\n#include \n\n#include \"gxf/core/component.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/stream/stream_nvsci.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\nclass StreamSync: public Stream {\n public:\n StreamSync() = default;\n ~StreamSync() = default;\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n gxf_result_t allocate_sync_object(SyncType signaler, SyncType waiter, void** syncObj) override;\n gxf_result_t signalSemaphore() override;\n gxf_result_t waitSemaphore() override;\n gxf_result_t setCudaStream(SyncType syncType, cudaStream_t stream) override;\n gxf_result_t importSemaphore(SyncType syncType) override;\n\n private:\n gxf_result_t importSemaphore(cudaExternalSemaphore_t* semaphore, SyncType syncType);\n\n NvSciSyncModule sync_module_{nullptr};\n NvSciSyncAttrList attr_list_{nullptr};\n NvSciSyncAttrList reconciled_attr_list_{nullptr};\n NvSciSyncObj sync_obj_{nullptr};\n NvSciSyncFence* fence_;\n cudaExternalSemaphore_t signaler_semaphore_;\n cudaExternalSemaphore_t waiter_semaphore_;\n cudaStream_t signaler_cuda_stream_{};\n cudaStream_t waiter_cuda_stream_{};\n bool is_signaler_semaphore_imported_{false};\n bool is_waiter_semaphore_imported_{false};\n int32_t num_gpus_{0};\n\n Parameter signaler_device_id_;\n Parameter waiter_device_id_;\n Parameter signaler_;\n Parameter waiter_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STREAM_STREAM_NVSCISYNC_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/stream/stream_sync_id.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STREAM_STREAM_SYNC_ID_HPP_\n#define NVIDIA_GXF_STREAM_STREAM_SYNC_ID_HPP_\n\n#include \"gxf/core/gxf.h\"\n\n\nnamespace nvidia {\nnamespace gxf {\n\n// The Structure indicates stream sync component ID.\n// Message entity carrying StreamSyncId indicates the ID of stream sync. The handle could\n// be deduced by Handle::Create(context, stream_sync_cid).\nstruct StreamSyncId {\n // component id of StreamSync\n gxf_uid_t stream_sync_cid;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STREAM_STREAM_SYNC_ID_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/stream/tests/test_gxf_stream_sync_cuda_helper.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_STREAM_TESTS_TEST_STREAM_CUDA_HELPER_HPP\n#define NVIDIA_GXF_STREAM_TESTS_TEST_STREAM_CUDA_HELPER_HPP\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"common/assert.hpp\"\n#include \"gxf/cuda/cuda_common.hpp\"\n#include \"gxf/cuda/cuda_stream.hpp\"\n#include \"gxf/cuda/cuda_stream_id.hpp\"\n#include \"gxf/cuda/cuda_stream_pool.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/tensor.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n#include \"gxf/stream/stream_nvsci.hpp\"\n#include \"gxf/stream/stream_nvscisync.hpp\"\n#include \"gxf/stream/stream_sync_id.hpp\"\n\n#define CHECK_CUBLUS_ERROR(cu_result, fmt, ...) \\\n do { \\\n cublasStatus_t err = (cu_result); \\\n if (err != CUBLAS_STATUS_SUCCESS) { \\\n GXF_LOG_ERROR(fmt \", cublas_error: %d\", ##__VA_ARGS__, (int)err); \\\n return Unexpected{GXF_FAILURE}; \\\n } \\\n } while (0)\n\nnamespace nvidia {\nnamespace gxf {\nnamespace stream {\nnamespace test {\n\nconstexpr static const char* kStreamName0 = \"CudaStream0\";\nconstexpr static int kDefaultDevId = 0;\nstatic const Shape kInitTensorShape{1024, 2048};\n\n// The base class with cuda stream utils\nclass StreamBasedOpsNew : public Codelet {\n public:\n static Expected> getStream(Entity& message) {\n auto stream_id = message.get();\n GXF_ASSERT(stream_id, \"failed to find cudastreamid\");\n auto stream =\n Handle::Create(stream_id.value().context(), stream_id.value()->stream_cid);\n GXF_ASSERT(stream, \"create cudastream from cid failed\");\n GXF_ASSERT(stream.value(), \"cudastream handle is null\");\n return stream;\n }\n\n static Expected addStream(Entity& message, Handle& stream,\n const char* name = nullptr) {\n auto stream_id = message.add(name);\n GXF_ASSERT(stream_id, \"failed to add cudastreamid\");\n stream_id.value()->stream_cid = stream.cid();\n GXF_ASSERT(stream_id.value()->stream_cid != kNullUid, \"stream_cid is null\");\n return Success;\n }\n\n static Expected> getStreamSync(Entity& message) {\n auto streamSync = message.get();\n GXF_ASSERT(streamSync, \"Failed to find StreamSync\");\n auto stream_sync = Handle::Create(streamSync.value().context(),\n streamSync.value()->stream_sync_cid);\n GXF_ASSERT(stream_sync, \"Create StreamSync from cid failed\");\n GXF_ASSERT(stream_sync.value(), \"StreamSync handle is null\");\n return stream_sync;\n }\n\n static Expected addStreamSync(Entity& message, Handle& streamSync,\n const char* name = nullptr) {\n auto stream_sync_id = message.add(name);\n GXF_ASSERT(stream_sync_id, \"Failed to add StreamSyncId\");\n stream_sync_id.value()->stream_sync_cid = streamSync.cid();\n GXF_ASSERT(stream_sync_id.value()->stream_sync_cid != kNullUid, \"stream_sync_cid is null\");\n return Success;\n }\n\n static Expected> addTensor(Entity& message, Handle pool,\n const TensorDescription& description) {\n GXF_ASSERT(pool, \"pool is not set\");\n auto tensor = message.add(description.name.c_str());\n GXF_ASSERT(tensor, \"failed to add message tensor\");\n const uint64_t bytes_per_element = description.element_type == PrimitiveType::kCustom\n ? description.bytes_per_element\n : PrimitiveTypeSize(description.element_type);\n\n auto result = tensor.value()->reshapeCustom(description.shape, description.element_type,\n bytes_per_element, description.strides,\n description.storage_type, pool);\n GXF_ASSERT(result, \"reshape tensor:%s failed\", description.name.c_str());\n return tensor;\n }\n};\n\n// Generate cuda tensor map with cudastreams for transmitter cuda_tx,\n// Generate host tensor map for transmitter host_tx\nclass StreamTensorGeneratorNew : public StreamBasedOpsNew {\n public:\n gxf_result_t initialize() override {\n GXF_ASSERT(stream_pool_.get(), \"stream pool is not set\");\n auto stream = stream_pool_->allocateStream();\n GXF_ASSERT(stream, \"allocating stream failed\");\n stream_ = std::move(stream.value());\n GXF_ASSERT(stream_->stream(), \"allocated stream is not initialized.\");\n\n stream_sync = stream_sync_.get();\n\n void *syncObj{nullptr};\n GXF_ASSERT_SUCCESS(stream_sync->allocate_sync_object(static_cast(signaler_.get()),\n static_cast(waiter_.get()),\n reinterpret_cast(&syncObj)));\n GXF_ASSERT(syncObj, \"syncObj is null\");\n\n GXF_ASSERT_SUCCESS(stream_sync->setCudaStream(static_cast(signaler_.get()),\n stream_->stream().value()));\n\n GXF_ASSERT_SUCCESS(stream_sync->setCudaStream(static_cast(waiter_.get()),\n stream_->stream().value()));\n\n return GXF_SUCCESS;\n }\n\n gxf_result_t tick() override {\n Expected maybe_dev_msg = Entity::New(context());\n GXF_ASSERT(maybe_dev_msg, \"New dev message failed\");\n auto& dev_msg = maybe_dev_msg.value();\n\n Expected maybe_host_msg = Entity::New(context());\n GXF_ASSERT(maybe_host_msg, \"New host message failed\");\n auto& host_msg = maybe_host_msg.value();\n\n auto ret = addStream(dev_msg, stream_, kStreamName0);\n GXF_ASSERT(ret, \"stream tensor generator adding stream failed\");\n\n auto sync_ret = addStreamSync(dev_msg, stream_sync, \"nvidia::gxf::StreamSync\");\n GXF_ASSERT_TRUE(sync_ret.has_value());\n auto maybe_stream_sync = getStreamSync(dev_msg);\n GXF_ASSERT_TRUE(maybe_stream_sync.has_value());\n\n ret = createTensors(dev_msg, host_msg, stream_->stream().value());\n GXF_ASSERT(ret, \"creating tensors failed\");\n GXF_ASSERT(stream_, \"stream is not allocated\");\n\n maybe_stream_sync.value()->signalSemaphore();\n\n ret = cuda_tx_->publish(dev_msg);\n if (!ret) {\n GXF_LOG_ERROR(\"stream tensor generator publishing cuda tensors failed\");\n return ToResultCode(ret);\n }\n\n if (host_tx_.get()) {\n ret = host_tx_->publish(host_msg);\n if (!ret) {\n GXF_LOG_ERROR(\"stream tensor generator publishing cuda tensors failed\");\n return ToResultCode(ret);\n }\n }\n\n return GXF_SUCCESS;\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(cuda_tx_, \"cuda_tx\", \"transmitter of cuda tensors\", \"\");\n result &= registrar->parameter(host_tx_, \"host_tx\", \"transmitter of host tensors\", \"\",\n Handle());\n result &= registrar->parameter(cuda_tensor_pool_, \"cuda_tensor_pool\", \"Cuda Tensor Pool\", \"\");\n result &= registrar->parameter(host_tensor_pool_, \"host_tensor_pool\", \"Host Tensor Pool\", \"\");\n result &= registrar->parameter(stream_pool_, \"stream_pool\", \"Cuda Stream Pool\", \"\");\n result &= registrar->parameter(stream_sync_, \"stream_sync\",\n \"Synchronization object across CUDA codelets\", \"\");\n result &= registrar->parameter(signaler_, \"signaler\", \"Signaler type\",\n \"Defines the signaler type. Cuda Signaler (2)\",\n static_cast(SyncType::GXF_STREAM_SIGNALER_CUDA));\n result &= registrar->parameter(waiter_, \"waiter\", \"Waiter type\",\n \"Defines the waiter type. Cuda Waiter (6)\",\n static_cast(SyncType::GXF_STREAM_WAITER_CUDA));\n return ToResultCode(result);\n }\n\n private:\n Expected createTensors(Entity& dev_msg, Entity& host_msg, cudaStream_t stream) {\n Shape shape = kInitTensorShape;\n for (size_t i = 0; i < 2; ++i) {\n TensorDescription dev_desc{\"cuda_tensor\", MemoryStorageType::kDevice, shape,\n PrimitiveType::kFloat32};\n auto cuda_tensor_ret = addTensor(dev_msg, cuda_tensor_pool_, dev_desc);\n GXF_ASSERT(cuda_tensor_ret, \"Generator dev message adding tensor failed.\");\n auto& cuda_tensor = cuda_tensor_ret.value();\n Expected cuda_data = cuda_tensor->data();\n if (!cuda_data) { return ForwardError(cuda_data); }\n\n TensorDescription host_desc{\"host_tensor\", MemoryStorageType::kHost, shape,\n PrimitiveType::kFloat32};\n auto host_tensor_ret = addTensor(host_msg, host_tensor_pool_, host_desc);\n GXF_ASSERT(host_tensor_ret, \"Generator host message adding tensor failed.\");\n auto& host_tensor = host_tensor_ret.value();\n Expected host_data = host_tensor->data();\n if (!host_data) { return ForwardError(host_data); }\n\n for (size_t j = 0; j < shape.size(); ++j) {\n host_data.value()[j] = (j % 100) + 1.0f;\n }\n\n cudaError_t error = cudaMemcpyAsync(cuda_data.value(), host_data.value(), cuda_tensor->size(),\n cudaMemcpyHostToDevice, stream);\n CHECK_CUDA_ERROR(error, \"StreamTensorGeneratorNew cuda memory cpy H2D failed.\");\n }\n\n return Success;\n }\n\n Parameter> cuda_tx_;\n Parameter> host_tx_;\n Parameter> cuda_tensor_pool_;\n Parameter> host_tensor_pool_;\n Parameter> stream_pool_;\n Parameter> stream_sync_;\n Parameter signaler_;\n Parameter waiter_;\n\n Handle stream_;\n Handle stream_sync;\n};\n\n// Dot product execution base class\nclass DotProductExeNew {\n private:\n Handle rx_;\n Handle tx_;\n Handle tensor_pool_;\n\n public:\n DotProductExeNew() = default;\n virtual ~DotProductExeNew() = default;\n void setEnv(const Handle& rx, const Handle& tx,\n const Handle& pool) {\n rx_ = rx;\n tx_ = tx;\n tensor_pool_ = pool;\n }\n\n virtual Expected dotproduct_i(float* in0, float* in1, float* out, int32_t row,\n int32_t column, Entity& in_msg, Entity& out_msg) = 0;\n\n Expected executeNew(Entity in_msg, const char* out_tensor_name = \"\") {\n GXF_ASSERT(rx_ && tx_ && tensor_pool_, \"dotproduct received empty in_msg\");\n\n // get tensors\n auto in_tensors = in_msg.findAllHeap();\n GXF_ASSERT(in_tensors, \"failed to find Tensors in in_msg\");\n GXF_ASSERT(in_tensors->size() == 2, \"doesn't find Tensors in in_msg\");\n GXF_ASSERT(in_tensors->at(0).value()->rank() == 2, \"Input tensor rank is not 2\");\n int32_t column = in_tensors->at(0).value()->shape().dimension(1);\n int32_t row = in_tensors->at(0).value()->shape().dimension(0);\n MemoryStorageType mem_type = in_tensors->at(0).value()->storage_type();\n PrimitiveType data_type = in_tensors->at(0).value()->element_type();\n\n float* in_data[2] = {nullptr};\n for (size_t i = 0; i < in_tensors->size(); ++i) {\n GXF_ASSERT(in_tensors->at(i).value(), \"Input Tensor Handle is empty\");\n GXF_ASSERT(in_tensors->at(i).value()->rank() == 2, \"Input tensor rank is not 2\");\n in_data[i] = ValuePointer(in_tensors->at(i).value()->pointer());\n }\n\n Expected output = Entity::New(in_msg.context());\n GXF_ASSERT(output, \"Creating dotproduct output tensor failed.\");\n Shape out_shape{row};\n GXF_ASSERT(out_shape.rank() == 1 && out_shape.size() == static_cast(row),\n \"output_shape is not correct\");\n TensorDescription outDesc{out_tensor_name, mem_type, out_shape, data_type};\n auto out_tensor = StreamBasedOpsNew::addTensor(output.value(), tensor_pool_, outDesc);\n GXF_ASSERT(out_tensor && out_tensor.value(), \"cuda dotproduct output tensor is not found\");\n float* out_data = ValuePointer(out_tensor.value()->pointer());\n auto ret =\n dotproduct_i(in_data[0], in_data[1], out_data, row, column, in_msg, output.value());\n GXF_ASSERT(ret, \"dotproduct execute with implementation failed\");\n ret = tx_->publish(output.value());\n GXF_ASSERT(ret, \"dotproduct publishing tensors failed\");\n return ret;\n }\n};\n\n// Cublas Dot product Operators\nclass CublasDotProductNew : public StreamBasedOpsNew {\n public:\n // Culblas dot production execution class\n class CublasDotProductExe : public DotProductExeNew {\n private:\n cublasHandle_t handle_ = nullptr;\n CublasDotProductNew* codelet_ = nullptr;\n\n public:\n CublasDotProductExe(CublasDotProductNew* codelet) : codelet_(codelet) {}\n ~CublasDotProductExe() {\n if (handle_) { cublasDestroy(handle_); }\n }\n Expected dotproduct_i(float* in0, float* in1, float* out, int32_t row, int32_t column,\n Entity& in_msg, Entity& out_msg) override {\n // locate stream\n auto maybe_stream = StreamBasedOpsNew::getStream(in_msg);\n GXF_ASSERT(maybe_stream && maybe_stream.value(), \"get stream from in_msg failed\");\n auto& stream = maybe_stream.value();\n auto ret = StreamBasedOpsNew::addStream(out_msg, stream);\n GXF_ASSERT(ret, \"adding cudastream into dotproduct output message failed.\");\n\n int gpu_id = stream->dev_id();\n if (gpu_id >= 0) {\n CHECK_CUDA_ERROR(cudaSetDevice(gpu_id), \"failed to set deviceid: %d\", gpu_id);\n }\n\n if (!handle_) {\n CHECK_CUBLUS_ERROR(cublasCreate(&handle_), \"failed to create cublas handle\");\n }\n auto custream_id = stream->stream();\n GXF_ASSERT(custream_id, \"cudastream id is invalid\");\n CHECK_CUBLUS_ERROR(cublasSetStream(handle_, custream_id.value()), \"cublas set stream failed\");\n\n for (int i = 0; i < row; ++i) {\n CHECK_CUBLUS_ERROR(\n cublasSdot(handle_, column, in0 + column * i, 1, in1 + column * i, 1, out + i),\n \"cublasSdot failed on row :%d\", i);\n }\n\n return ret;\n }\n };\n\n CublasDotProductNew() : exec_(this) {}\n\n gxf_result_t initialize() override {\n GXF_ASSERT(tensor_pool_.get() && rx_.get() && tx_.get(), \"params not set\");\n exec_.setEnv(rx_.get(), tx_.get(), tensor_pool_.get());\n return GXF_SUCCESS;\n }\n\n // gxf_result_t start() override { return ToResultCode(initOpsEvent()); }\n\n gxf_result_t tick() override {\n Expected in_msg = rx_->receive();\n\n auto maybe_stream_sync = getStreamSync(in_msg.value());\n GXF_ASSERT_TRUE(maybe_stream_sync.has_value());\n\n maybe_stream_sync.value()->waitSemaphore();\n\n auto ret = exec_.executeNew(in_msg.value(), \"cublasdotproduct_tensor\");\n return ToResultCode(ret);\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(tx_, \"tx\", \"transmitter of tensors\", \"\");\n result &= registrar->parameter(rx_, \"rx\", \"receiver of tensors\", \"\");\n result &= registrar->parameter(tensor_pool_, \"tensor_pool\", \"Tensor Pool\", \"\");\n return ToResultCode(result);\n }\n\n private:\n Parameter> tx_;\n Parameter> rx_;\n Parameter> tensor_pool_;\n\n CublasDotProductExe exec_;\n};\n\n// CPU Dot product Operators\nclass HostDotProductNew : public Codelet {\n public:\n // CPU dot production execution class\n class HostDotProductExeNew : public DotProductExeNew {\n public:\n HostDotProductExeNew() = default;\n ~HostDotProductExeNew() = default;\n Expected dotproduct_i(float* in0, float* in1, float* out, int32_t row, int32_t column,\n Entity& in_msg, Entity& out_msg) override {\n for (int i = 0; i < row; ++i) {\n float sum = 0.0;\n float* x = in0 + column * i;\n float* y = in1 + column * i;\n for (int j = 0; j < column; ++j) { sum += x[j] * y[j]; }\n out[i] = sum;\n }\n return Success;\n }\n };\n\n gxf_result_t initialize() override {\n GXF_ASSERT(tensor_pool_.get() && rx_.get() && tx_.get(), \"params not set\");\n exec_.setEnv(rx_.get(), tx_.get(), tensor_pool_.get());\n return GXF_SUCCESS;\n }\n\n gxf_result_t tick() override {\n Expected in_msg = rx_->receive();\n\n\n auto ret = exec_.executeNew(in_msg.value(), \"host_dotproduct_tensor\");\n return ToResultCode(ret);\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(tx_, \"tx\", \"transmitter of tensors\", \"\");\n result &= registrar->parameter(rx_, \"rx\", \"receiver of tensors\", \"\");\n result &= registrar->parameter(tensor_pool_, \"tensor_pool\", \"Tensor Pool\", \"\");\n return ToResultCode(result);\n }\n\n private:\n Parameter> tx_;\n Parameter> rx_;\n Parameter> tensor_pool_;\n\n HostDotProductExeNew exec_;\n};\n\n// Stream based Memory copy from device to host\nclass MemCpy2HostNew : public StreamBasedOpsNew {\n public:\n gxf_result_t tick() override {\n auto in = rx_->receive();\n GXF_ASSERT(in, \"rx received empty message\");\n auto maybe_tensor = in.value().get();\n GXF_ASSERT(maybe_tensor, \"tensor not found\");\n auto& in_tensor = maybe_tensor.value();\n byte* in_data = in_tensor->pointer();\n\n Expected out_msg = Entity::New(context());\n TensorDescription out_desc{in_tensor.name(), MemoryStorageType::kHost, in_tensor->shape(),\n in_tensor->element_type()};\n auto maybe_out_tensor = addTensor(out_msg.value(), tensor_pool_, out_desc);\n GXF_ASSERT(maybe_out_tensor, \"Memcpy host message adding tensor failed.\");\n auto& out_tensor = maybe_out_tensor.value();\n byte* out_data = out_tensor->pointer();\n\n auto maybe_stream = getStream(in.value());\n GXF_ASSERT(maybe_stream && maybe_stream.value(), \"get stream from in failed\");\n auto& stream = maybe_stream.value();\n auto ret = addStream(out_msg.value(), stream);\n GXF_ASSERT(ret, \"adding cudastream into memcpy output message failed.\");\n\n // wrap cuda operations since CHECK_CUDA_ERROR return Expected\n ret = [&, this]() -> Expected {\n int gpu_id = stream->dev_id();\n if (gpu_id >= 0) {\n CHECK_CUDA_ERROR(cudaSetDevice(gpu_id), \"failed to set deviceid: %d\", gpu_id);\n }\n cudaError_t error = cudaMemcpyAsync(out_data, in_data, in_tensor->size(),\n cudaMemcpyDeviceToHost, stream->stream().value());\n CHECK_CUDA_ERROR(error, \"CUDA memory cpy to host failed.\");\n return Success;\n }();\n GXF_ASSERT(ret, \"CUDA memory cpy to host failed.\");\n\n ret = tx_->publish(out_msg.value());\n GXF_ASSERT(ret, \"memcpy_to_host publishing tensors failed\");\n\n return ToResultCode(ret);\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(tx_, \"tx\", \"transmitter of tensors\", \"\");\n result &= registrar->parameter(rx_, \"rx\", \"receiver of tensors\", \"\");\n result &= registrar->parameter(tensor_pool_, \"tensor_pool\", \"Tensor output pool\", \"\");\n return ToResultCode(result);\n }\n\n private:\n Parameter> tx_;\n Parameter> rx_;\n Parameter> tensor_pool_;\n};\n\n// Equal verification\nclass VerifyEqualNew : public Codelet {\n public:\n gxf_result_t tick() override {\n GXF_LOG_DEBUG(\"verifying frame: %d\", count_++);\n auto in0 = rx0_->receive();\n GXF_ASSERT(in0, \"rx0 received empty message\");\n auto in1 = rx1_->receive();\n GXF_ASSERT(in1, \"rx1 received empty message\");\n\n // get tensors\n auto maybe_tensor0 = in0.value().get();\n GXF_ASSERT(maybe_tensor0, \"tensor0 not found\");\n auto maybe_tensor1 = in1.value().get();\n GXF_ASSERT(maybe_tensor1, \"tensor1 not found\");\n auto& tensor0 = maybe_tensor0.value();\n auto& tensor1 = maybe_tensor1.value();\n GXF_ASSERT(std::string(tensor0.name()) != std::string(tensor1.name()),\n \"2 tensor name should not same\");\n GXF_ASSERT(tensor0->shape() == tensor1->shape(), \"2 tensors' shape not matched\");\n GXF_ASSERT(tensor0->element_type() == tensor1->element_type(),\n \"2 tensor's element type not matched\");\n GXF_ASSERT(tensor0->storage_type() == tensor1->storage_type(),\n \"2 tensor's storage_type not matched\");\n GXF_ASSERT(tensor0->storage_type() == MemoryStorageType::kHost,\n \"very tensor storage_type is not from host\");\n\n float* data0 = tensor0->data().value();\n float* data1 = tensor1->data().value();\n uint64_t count = tensor0->element_count();\n for (uint64_t i = 0; i < count; ++i) {\n GXF_ASSERT(fequal(data0[i], data1[i]), \"data0[%d]: %f but data1: %f.\", static_cast(i),\n data0[i], data1[i]);\n }\n\n return GXF_SUCCESS;\n }\n\n gxf_result_t registerInterface(Registrar* registrar) override {\n Expected result;\n result &= registrar->parameter(rx0_, \"rx0\", \"receiver0 of tensors\", \"\");\n result &= registrar->parameter(rx1_, \"rx1\", \"receiver1 of tensors\", \"\");\n return ToResultCode(result);\n }\n\n private:\n bool fequal(float a, float b) {\n if (fabs(a - b) <= std::numeric_limits::epsilon()) return true;\n return false;\n }\n Parameter> rx0_;\n Parameter> rx1_;\n int32_t count_ = 0;\n};\n\n} // namespace test\n\n} // namespace stream\n\n} // namespace gxf\n\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_STREAM_TESTS_TEST_STREAM_CUDA_HELPER_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_common.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#ifndef NVIDIA_GXF_UCX_UCX_COMMON_HPP_\n#define NVIDIA_GXF_UCX_UCX_COMMON_HPP_\n\n#include /* inet_addr */\n\n#include \n#include \n#include \"gxf/std/allocator.hpp\"\n\n#define DEFAULT_UCX_PORT 13337U\n#define TEST_AM_ID 0\n#define WORKER_PROGRESS_ITERATIONS 5\nnamespace nvidia {\nnamespace gxf {\n\ntypedef struct _ucx_am_data_desc {\n volatile int complete;\n void *desc;\n volatile size_t msg_length;\n volatile size_t header_length;\n void *recv_buf;\n void *header;\n volatile size_t num_of_comps;\n bool receiving_message;\n ucs_memory_type_t mem_type;\n} ucx_am_data_desc;\n/**\n * Stream request context. Holds a value to indicate whether or not the\n * request is completed.\n */\ntypedef struct test_req {\n int complete;\n char *header;\n} test_req_t;\n\n typedef enum {\n INIT,\n CONNECTED,\n RESET,\n CLOSED,\n RECEIVE_MESSAGE\n } ConnState;\n\n#define CHECK_RETURN_FAILURE(value) \\\n if ((value) != GXF_SUCCESS) return (value);\n\ntypedef struct UcxTransmitterSendContext {\n Entity entity;\n ucp_worker_h ucp_worker;\n void* request;\n test_req_t* ctx;\n int index;\n} UcxTransmitterSendContext_;\n/**\n * Set an address for the server to listen on - INADDR_ANY on a well known port.\n */\nvoid set_sock_addr(const char* address_str, int port, struct sockaddr_storage* saddr);\n\nvoid ep_close(ucp_worker_h ucp_worker, ucp_ep_h ep, uint32_t mode);\n\ngxf_result_t init_worker(ucp_context_h ucp_context, ucp_worker_h* ucp_worker);\n\nucs_memory_type_t ucx_mem_type(MemoryStorageType gxf_mem_type);\n\nucs_status_t request_wait(ucp_worker_h ucp_worker, void* request,\n test_req_t* ctx);\n\ngxf_result_t request_finalize(ucp_worker_h ucp_worker, void* request,\n test_req_t* ctx);\n\nucs_status_t request_wait_once(ucp_worker_h ucp_worker, void* request,\n test_req_t* ctx);\n\nucs_status_t process_request(ucp_worker_h ucp_worker, void* req);\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_EXTENSIONS_UCX_UCX_COMMON_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_component_serializer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_UCX_COMPONENT_SERIALIZER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_UCX_COMPONENT_SERIALIZER_HPP_\n\n#include \"common/endian.hpp\"\n#include \"gxf/multimedia/audio.hpp\"\n#include \"gxf/multimedia/video.hpp\"\n#include \"gxf/serialization/component_serializer.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/eos.hpp\"\n#include \"gxf/std/tensor.hpp\"\n#include \"gxf/std/timestamp.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Serializer that supports serializaing Timestamps, Tensors, Video Buffer,\n// Audio Buffer and integer components\n// Valid for sharing data between devices with the same endianness\nclass UcxComponentSerializer : public ComponentSerializer {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override { return GXF_SUCCESS; }\n\n private:\n // Configures all serializer functions\n Expected configureSerializers();\n // Configures all deserializer functions\n Expected configureDeserializers();\n // Serializes a nvidia::gxf::Timestamp\n Expected serializeTimestamp(Timestamp timestamp, Endpoint* endpoint);\n // Deserializes a nvidia::gxf::Timestamp\n Expected deserializeTimestamp(Endpoint* endpoint);\n // Serializes a nvidia::gxf::Tensor\n Expected serializeTensor(const Tensor& tensor, Endpoint* endpoint);\n // Deserializes a nvidia::gxf::Tensor\n Expected deserializeTensor(Endpoint* endpoint);\n // Serializes a nvidia::gxf::VideoBuffer\n Expected serializeVideoBuffer(const VideoBuffer& videoBuffer, Endpoint* endpoint);\n // Deserializes a nvidia::gxf::VideoBuffer\n Expected deserializeVideoBuffer(Endpoint* endpoint);\n // Serializes a nvidia::gxf::AudioBuffer\n Expected serializeAudioBuffer(const AudioBuffer& audioBuffer, Endpoint* endpoint);\n // Deserializes a nvidia::gxf::AudioBuffer\n Expected deserializeAudioBuffer(Endpoint* endpoint);\n // Serializes a nvidia::gxf::EndOfStream\n Expected serializeEndOfStream(EndOfStream& eos, Endpoint* endpoint);\n // Deserializes a nvidia::gxf::EndOfStream\n Expected deserializeEndOfStream(Endpoint* endpoint);\n // Serializes an integer\n template \n Expected serializeInteger(T value, Endpoint* endpoint) {\n if (!endpoint) {\n return Unexpected{GXF_ARGUMENT_NULL};\n }\n T encoded = EncodeLittleEndian(value);\n return endpoint->writeTrivialType(&encoded);\n }\n // Deserializes an integer\n template \n Expected deserializeInteger(Endpoint* endpoint) {\n if (!endpoint) {\n return Unexpected{GXF_ARGUMENT_NULL};\n }\n T encoded;\n return endpoint->readTrivialType(&encoded)\n .and_then([&]() { return DecodeLittleEndian(encoded); });\n }\n\n Parameter> allocator_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_STD_COMPONENT_SERIALIZER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_context.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_UCX_UCX_ROUTER_HPP_\n#define NVIDIA_GXF_UCX_UCX_ROUTER_HPP_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/std/network_context.hpp\"\n#include \"gxf/std/queue.hpp\"\n\n#include \"ucx_common.hpp\"\n#include \"ucx_receiver.hpp\"\n#include \"ucx_transmitter.hpp\"\n\n#define kMaxRxContexts 1024\n\nnamespace nvidia {\nnamespace gxf {\n\ntypedef struct ucx_server_ctx {\n volatile ucp_conn_request_h conn_request;\n ucp_listener_h listener;\n ucp_worker_h listener_worker;\n int listener_fd; ///< epoll fd used only when enable_async_ == true\n} ucx_server_ctx_t;\n\n\n\ntypedef struct UcxReceiverContext {\n UcxReceiver *rx;\n ucx_server_ctx_t server_context;\n ucp_ep_h ep;\n ConnState conn_state;\n ucx_am_data_desc am_data_desc;\n FixedVector, kMaxRxContexts> headers;\n ucp_worker_h ucp_worker;\n int worker_fd; ///< epoll fd used only when enable_async_ == true\n int index;\n} UcxReceiverContext_;\n\ntypedef struct UcxTransmitterContext {\n UcxTransmitter *tx;\n ucp_ep_h ep;\n ucp_worker_h ucp_worker;\n bool connection_closed;\n int index;\n} UcxTransmitterContext_;\n\ntypedef struct ConnManager {\n int total;\n int connected;\n int closed;\n} ConnManager_;\n\n\n// The class which initializes UCX context and connection worker\nclass UcxContext : public NetworkContext {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n Expected addRoutes(const Entity& entity) override;\n Expected removeRoutes(const Entity& entity) override;\n\n private:\n gxf_result_t init_context();\n gxf_result_t init_tx(Handle tx);\n gxf_result_t init_rx(Handle rx);\n\n /// @brief start server for the case with enable_async_ == false\n void start_server();\n\n gxf_result_t am_desc_to_iov(std::shared_ptr rx_context);\n void destroy_rx_contexts();\n void destroy_tx_contexts();\n\n // The remaining methods are specific to the case with enable_async_ == true\n\n /// @brief start server for the case with enable_async_ == true\n void start_server_async_queue();\n /// @brief method run by tx_thread_ when enable_async_ == true\n void poll_queue();\n gxf_result_t wait_for_event(); ///< primary function called by start_server_async_queue\n gxf_result_t epoll_add_worker(std::shared_ptr rx_context,\n bool is_listener);\n gxf_result_t progress_work(std::shared_ptr rx_context);\n gxf_result_t server_create_ep(std::shared_ptr rx_context);\n gxf_result_t init_connection(std::shared_ptr rx_context);\n gxf_result_t handle_connections_after_recv();\n gxf_result_t gxf_arm_worker(std::shared_ptr rx_context,\n bool is_listener);\n void copy_header_to_am_desc(std::shared_ptr rx_context);\n\n bool close_server_loop_;\n FixedVector, kMaxRxContexts> rx_contexts_;\n FixedVector, kMaxRxContexts> tx_contexts_;\n ucp_context_h ucp_context_;\n Parameter> entity_serializer_;\n Parameter reconnect_;\n Resource> gpu_device_;\n Parameter cpu_data_only_;\n Parameter enable_async_;\n int32_t dev_id_ = 0;\n\n std::thread t_; ///< server thread used only when enable_async_ == false\n\n // The following data members are only used when enable_async_ == true\n ConnManager rx_conns_ = {0};\n std::thread rx_thread_; ///< async receiver thread used only when enable_async_ == true\n std::thread tx_thread_; ///< async transmitter thread used only when enable_async_ == true\n std::list pending_send_requests_;\n std::mutex mtx_;\n std::condition_variable cv_;\n bool areTransmittersDone = false;\n int epoll_fd_;\n int efd_signal_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_entity_serializer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_UCX_ENTITY_SERIALIZER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_UCX_ENTITY_SERIALIZER_HPP_\n\n#define kMaxTempComponents 1024\n\n#include \n\n#include \"common/fixed_vector.hpp\"\n#include \"gxf/core/gxf.h\"\n#include \"gxf/serialization/component_serializer.hpp\"\n#include \"gxf/serialization/entity_serializer.hpp\"\n#include \"gxf/serialization/tid_hash.hpp\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Serializes and deserializes entities with the provided component serializers\n// Little-endian is used over big-endian for better performance on x86 and arm platforms\n// Entities are serialized in the following format:\n//\n// | Entity Header | Component Header | Component Metadata | Component Header | ... | ... |\n//\n// Components will be serialized in the order they are added to the entity\n// Components without serializers will be skipped\n// Each component will be preceded by a component header and the name of the component\n// The component itself will be serialized with a component serializer\n// An entity header will be added at the beginning\nclass UcxEntitySerializer : public EntitySerializer {\n public:\n #pragma pack(push, 1)\n // Header preceding entities\n struct EntityHeader {\n uint64_t serialized_size; // Size of the serialized entity in bytes\n uint64_t sequence_number; // Sequence number of the message\n uint64_t component_count; // Number of components in the entity\n };\n #pragma pack(pop)\n\n #pragma pack(push, 1)\n // Header preceding components\n struct ComponentHeader {\n uint64_t serialized_size; // Size of the serialized component in bytes\n gxf_tid_t tid; // Type ID of the component\n char name[kMaxComponentNameSize]; // Component name\n };\n #pragma pack(pop)\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override { return GXF_SUCCESS; }\n gxf_result_t deinitialize() override { return GXF_SUCCESS; }\n\n gxf_result_t serialize_entity_abi(gxf_uid_t eid, Endpoint* endpoint, uint64_t* size) override;\n gxf_result_t deserialize_entity_abi(gxf_uid_t eid, Endpoint* endpoint) override;\n Expected deserialize_entity_header_abi(Endpoint* endpoint) override;\n\n Expected add_serializer(const Handle& serializer);\n\n private:\n // Structure used to organize serializable components\n struct ComponentEntry;\n\n using ComponentSerializerList = FixedVector, kMaxTempComponents>;\n\n // Populates a list of component entries using a list of component handles\n Expected> createComponentEntries(\n const FixedVector& components);\n // Serializes a list of components and writes them to an endpoint\n // Returns the total number of bytes serialized\n Expected serializeComponents(const FixedVector& entries,\n Endpoint* endpoint);\n // Reads from an endpoint and deserializes a list of components\n Expected deserializeComponents(size_t component_count, Entity entity, Endpoint* endpoint);\n // Searches for a component serializer that supports the given type ID\n // Uses the first valid serializer found and caches it for subsequent lookups\n // Returns an Unexpected if no valid serializer is found\n Expected> findComponentSerializer(gxf_tid_t tid);\n\n Parameter component_serializers_;\n Parameter verbose_warning_;\n\n // Table that caches type ID with a valid component serializer\n std::unordered_map, TidHash> serializer_cache_;\n // Sequence number for outgoing messages\n uint64_t outgoing_sequence_number_{0};\n // Sequence number for incoming messages\n uint64_t incoming_sequence_number_{0};\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_STD_ENTITY_SERIALIZER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_receiver.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gxf/std/gems/staging_queue/staging_queue.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/resources.hpp\"\n\n#include \"ucx_common.hpp\"\n#include \"ucx_serialization_buffer.hpp\"\n\n#ifndef NVIDIA_GXF_UCX_UCX_RECEIVER_HPP_\n#define NVIDIA_GXF_UCX_UCX_RECEIVER_HPP_\n\nnamespace nvidia {\nnamespace gxf {\n\n\n// Codelet that functions as a receiver on a UCX connection\nclass UcxReceiver : public Receiver {\n public:\n using queue_t = ::gxf::staging_queue::StagingQueue;\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n gxf_result_t init_context(ucp_worker_h ucp_worker,\n ucx_am_data_desc* am_data_desc, int fd,\n bool cpu_data_only, bool enable_async);\n\n gxf_result_t pop_abi(gxf_uid_t* uid) override;\n\n gxf_result_t push_abi(gxf_uid_t other) override;\n\n gxf_result_t peek_abi(gxf_uid_t* uid, int32_t index) override;\n\n gxf_result_t peek_back_abi(gxf_uid_t* uid, int32_t index) override;\n\n size_t capacity_abi() override;\n\n size_t size_abi() override;\n\n gxf_result_t receive_abi(gxf_uid_t* uid) override;\n\n size_t back_size_abi() override;\n\n gxf_result_t sync_abi() override;\n\n gxf_result_t sync_io_abi() override;\n\n gxf_result_t wait_abi() override;\n const char* get_addr();\n\n int get_port();\n\n Expected set_serialization_buffer(Handle buffer);\n\n Expected set_port(int port);\n\n Parameter capacity_;\n Parameter policy_;\n Parameter address_;\n Parameter port_;\n Resource> gpu_device_;\n Parameter> buffer_;\n\n private:\n gxf_result_t receive_message();\n\n /// @brief finalize request when enable_async_ == false\n gxf_result_t request_finalize_sync(ucp_worker_h ucp_worker, test_req_t* request,\n test_req_t* ctx);\n\n ucp_worker_h ucp_worker_;\n ucx_am_data_desc* am_data_desc_;\n std::unique_ptr queue_;\n int32_t dev_id_ = 0;\n int efd_signal_;\n bool cpu_data_only_ = false;\n std::list> requests;\n int enable_async_ = true;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_EXTENSIONS_UCX_UCX_RECEIVER_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_serialization_buffer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#ifndef NVIDIA_GXF_SERIALIZATION_UCX_SERIALIZATION_BUFFER_HPP_\n#define NVIDIA_GXF_SERIALIZATION_UCX_SERIALIZATION_BUFFER_HPP_\n\n#include \n#include \n\n#include \"gxf/serialization/endpoint.hpp\"\n#include \"gxf/std/allocator.hpp\"\n#include \"gxf/std/memory_buffer.hpp\"\n\n#include \"ucp/api/ucp.h\"\n\nnamespace nvidia {\nnamespace gxf {\n\n// Buffer to hold serialized data\nclass UcxSerializationBuffer : public Endpoint {\n public:\n gxf_result_t registerInterface(Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override { return ToResultCode(buffer_.freeBuffer()); }\n\n gxf_result_t write_abi(const void* data, size_t size, size_t* bytes_written) override;\n gxf_result_t read_abi(void* data, size_t size, size_t* bytes_read) override;\n\n gxf_result_t write_ptr_abi(const void* pointer, size_t size, MemoryStorageType type) override;\n\n // Resizes the buffer\n gxf::Expected resize(size_t size);\n\n // Set allocator\n Expected set_allocator(Handle allocator);\n\n // Returns a read-only pointer to buffer data\n const byte* data() const { return buffer_.pointer(); }\n const ucp_dt_iov_t* iov_buffer() const { return iov_buffers_.data(); }\n const size_t iov_buffer_size() const { return iov_buffers_.size(); }\n const ucs_memory_type_t mem_type() const {return mem_type_; }\n // Returns the capacity of the buffer\n size_t capacity() const { return buffer_.size(); }\n // Returns the number of bytes written to the buffer\n size_t size() const;\n // Resets buffer for sequential access\n void reset();\n uint64_t sequence_number_ = 0;\n\n private:\n Parameter> allocator_;\n Parameter buffer_size_;\n // Vector for ucp_dt_iov_t\n std::vector iov_buffers_;\n // UCX memory type of component\n ucs_memory_type_t mem_type_;\n // Data buffer\n MemoryBuffer buffer_;\n // Offset for sequential writes\n size_t write_offset_;\n // Offset for sequential reads\n size_t read_offset_;\n // Mutex to guard concurrent access\n mutable std::mutex mutex_;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_SERIALIZATION_UCX_SERIALIZATION_BUFFER_HPP_\n" }, { "path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_transmitter.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"ucp/api/ucp.h\"\n\n#include \"gxf/std/gems/staging_queue/staging_queue.hpp\"\n#include \"gxf/std/resources.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n#include \"ucx_common.hpp\"\n#include \"ucx_entity_serializer.hpp\"\n#include \"ucx_serialization_buffer.hpp\"\n\n#ifndef NVIDIA_GXF_UCX_UCX_TRANSMITTER_HPP_\n#define NVIDIA_GXF_UCX_UCX_TRANSMITTER_HPP_\n\nnamespace nvidia {\nnamespace gxf {\n\n// Codelet that functions as a transmitter in a UCX connection\nclass UcxTransmitter : public Transmitter {\n public:\n using queue_t = ::gxf::staging_queue::StagingQueue;\n\n gxf_result_t init_context(ucp_context_h ucp_context,\n Handle serializer,\n ucp_worker_h ucp_worker,\n ucp_ep_h* ep,\n bool* connection_closed_p,\n bool reconnect,\n bool cpu_data_only,\n bool enable_async,\n std::list* send_queue,\n std::condition_variable* cv,\n std::mutex* mtx);\n\n gxf_result_t registerInterface(Registrar* registrar) override;\n\n gxf_result_t initialize() override;\n\n gxf_result_t deinitialize() override;\n\n gxf_result_t pop_abi(gxf_uid_t* uid) override;\n\n gxf_result_t pop_io_abi(gxf_uid_t* uid) override;\n\n gxf_result_t push_abi(gxf_uid_t other) override;\n\n gxf_result_t peek_abi(gxf_uid_t* uid, int32_t index) override;\n\n size_t capacity_abi() override;\n\n size_t size_abi() override;\n\n gxf_result_t publish_abi(gxf_uid_t uid) override;\n\n size_t back_size_abi() override;\n\n gxf_result_t sync_abi() override;\n\n gxf_result_t sync_io_abi() override;\n\n Expected set_port(int port);\n\n Expected set_serialization_buffer(Handle buffer);\n\n Parameter capacity_;\n Parameter policy_;\n\n private:\n gxf_result_t send_am(Entity& entity);\n gxf_result_t create_client_connection();\n gxf_result_t create_client_connection_with_retries();\n gxf_result_t check_connection_and_connect();\n\n ucp_worker_h ucp_worker_;\n ucp_ep_h* ep_;\n Parameter receiver_address_;\n Parameter local_address_;\n Parameter port_;\n Parameter local_port_;\n Parameter maximum_connection_retries_;\n Resource> gpu_device_;\n int32_t dev_id_ = 0;\n Parameter> buffer_;\n\n Handle entity_serializer_;\n std::unique_ptr queue_;\n bool* connection_closed_p_;\n bool reconnect_;\n bool cpu_data_only_;\n std::list* send_queue_;\n std::condition_variable* cv_;\n std::mutex* mtx_;\n int index = 0;\n int* id_;\n int enable_async_ = true;\n};\n\n} // namespace gxf\n} // namespace nvidia\n\n#endif // NVIDIA_GXF_EXTENSIONS_UCX_UCX_TRANSMITTER_HPP\n" }, { "path": "isaac_ros_gxf/gxf/core/include/third_party/LICENSE.txt", "content": "================================================================================\nThis project uses the following software and the following licensing terms\napply to all the extensions and its associated files used to interact with the\ngraph composer tools suite that includes composer, registry, container builder\nand gxe.\n\n================================================================================\npython 3.6.9 (Provided under following license)\n================================================================================\n\nPython was created in the early 1990s by Guido van Rossum at Stichting Mathematisch Centrum (CWI, see https://www.cwi.nl/) in the Netherlands as a successor of a language called ABC. Guido remains Python’s principal author, although it includes many contributions from others.\n\nIn 1995, Guido continued his work on Python at the Corporation for National Research Initiatives (CNRI, see https://www.cnri.reston.va.us/) in Reston, Virginia where he released several versions of the software.\n\nIn May 2000, Guido and the Python core development team moved to BeOpen.com to form the BeOpen PythonLabs team. In October of the same year, the PythonLabs team moved to Digital Creations (now Zope Corporation; see https://www.zope.org/). In 2001, the Python Software Foundation (PSF, see https://www.python.org/psf/) was formed, a non-profit organization created specifically to own Python-related Intellectual Property. Zope Corporation is a sponsoring member of the PSF.\n\nAll Python releases are Open Source (see https://opensource.org/ for the Open Source Definition). Historically, most, but not all, Python releases have also been GPL-compatible; the table below summarizes the various releases.\n\n\n Release Derived Year Owner GPL-\n from compatible? (1)\n\n 0.9.0 thru 1.2 1991-1995 CWI yes\n 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes\n 1.6 1.5.2 2000 CNRI no\n 2.0 1.6 2000 BeOpen.com no\n 1.6.1 1.6 2001 CNRI yes (2)\n 2.1 2.0+1.6.1 2001 PSF no\n 2.0.1 2.0+1.6.1 2001 PSF yes\n 2.1.1 2.1+2.0.1 2001 PSF yes\n 2.1.2 2.1.1 2002 PSF yes\n 2.1.3 2.1.2 2002 PSF yes\n 2.2 and above 2.1.1 2001-now PSF yes\n\nNote\n\nGPL-compatible doesn’t mean that we’re distributing Python under the GPL. All Python licenses, unlike the GPL, let you distribute a modified version without making your changes open source. The GPL-compatible licenses make it possible to combine Python with other software that is released under the GPL; the others don’t.\n\nThanks to the many outside volunteers who have worked under Guido’s direction to make these releases possible.\nTerms and conditions for accessing or otherwise using Python\nPSF LICENSE AGREEMENT FOR PYTHON 3.6.13\n\n1. This LICENSE AGREEMENT is between the Python Software Foundation (\"PSF\"), and\n the Individual or Organization (\"Licensee\") accessing and otherwise using Python\n 3.6.13 software in source or binary form and its associated documentation.\n\n2. Subject to the terms and conditions of this License Agreement, PSF hereby\n grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,\n analyze, test, perform and/or display publicly, prepare derivative works,\n distribute, and otherwise use Python 3.6.13 alone or in any derivative\n version, provided, however, that PSF's License Agreement and PSF's notice of\n copyright, i.e., \"Copyright © 2001-2021 Python Software Foundation; All Rights\n Reserved\" are retained in Python 3.6.13 alone or in any derivative version\n prepared by Licensee.\n\n3. In the event Licensee prepares a derivative work that is based on or\n incorporates Python 3.6.13 or any part thereof, and wants to make the\n derivative work available to others as provided herein, then Licensee hereby\n agrees to include in any such work a brief summary of the changes made to Python\n 3.6.13.\n\n4. PSF is making Python 3.6.13 available to Licensee on an \"AS IS\" basis.\n PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF\n EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR\n WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE\n USE OF PYTHON 3.6.13 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 3.6.13\n FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF\n MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 3.6.13, OR ANY DERIVATIVE\n THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n6. This License Agreement will automatically terminate upon a material breach of\n its terms and conditions.\n\n7. Nothing in this License Agreement shall be deemed to create any relationship\n of agency, partnership, or joint venture between PSF and Licensee. This License\n Agreement does not grant permission to use PSF trademarks or trade name in a\n trademark sense to endorse or promote products or services of Licensee, or any\n third party.\n\n8. By copying, installing or otherwise using Python 3.6.13, Licensee agrees\n to be bound by the terms and conditions of this License Agreement.\n\nBEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0\n\nBEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1\n\n1. This LICENSE AGREEMENT is between BeOpen.com (\"BeOpen\"), having an office at\n 160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization\n (\"Licensee\") accessing and otherwise using this software in source or binary\n form and its associated documentation (\"the Software\").\n\n2. Subject to the terms and conditions of this BeOpen Python License Agreement,\n BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license\n to reproduce, analyze, test, perform and/or display publicly, prepare derivative\n works, distribute, and otherwise use the Software alone or in any derivative\n version, provided, however, that the BeOpen Python License is retained in the\n Software, alone or in any derivative version prepared by Licensee.\n\n3. BeOpen is making the Software available to Licensee on an \"AS IS\" basis.\n BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF\n EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR\n WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE\n USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR\n ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING,\n MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF\n ADVISED OF THE POSSIBILITY THEREOF.\n\n5. This License Agreement will automatically terminate upon a material breach of\n its terms and conditions.\n\n6. This License Agreement shall be governed by and interpreted in all respects\n by the law of the State of California, excluding conflict of law provisions.\n Nothing in this License Agreement shall be deemed to create any relationship of\n agency, partnership, or joint venture between BeOpen and Licensee. This License\n Agreement does not grant permission to use BeOpen trademarks or trade names in a\n trademark sense to endorse or promote products or services of Licensee, or any\n third party. As an exception, the \"BeOpen Python\" logos available at\n http://www.pythonlabs.com/logos.html may be used according to the permissions\n granted on that web page.\n\n7. By copying, installing or otherwise using the software, Licensee agrees to be\n bound by the terms and conditions of this License Agreement.\n\nCNRI LICENSE AGREEMENT FOR PYTHON 1.6.1\n\n1. This LICENSE AGREEMENT is between the Corporation for National Research\n Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191\n (\"CNRI\"), and the Individual or Organization (\"Licensee\") accessing and\n otherwise using Python 1.6.1 software in source or binary form and its\n associated documentation.\n\n2. Subject to the terms and conditions of this License Agreement, CNRI hereby\n grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,\n analyze, test, perform and/or display publicly, prepare derivative works,\n distribute, and otherwise use Python 1.6.1 alone or in any derivative version,\n provided, however, that CNRI's License Agreement and CNRI's notice of copyright,\n i.e., \"Copyright © 1995-2001 Corporation for National Research Initiatives; All\n Rights Reserved\" are retained in Python 1.6.1 alone or in any derivative version\n prepared by Licensee. Alternately, in lieu of CNRI's License Agreement,\n Licensee may substitute the following text (omitting the quotes): \"Python 1.6.1\n is made available subject to the terms and conditions in CNRI's License\n Agreement. This Agreement together with Python 1.6.1 may be located on the\n Internet using the following unique, persistent identifier (known as a handle):\n 1895.22/1013. This Agreement may also be obtained from a proxy server on the\n Internet using the following URL: http://hdl.handle.net/1895.22/1013.\";\n\n3. In the event Licensee prepares a derivative work that is based on or\n incorporates Python 1.6.1 or any part thereof, and wants to make the derivative\n work available to others as provided herein, then Licensee hereby agrees to\n include in any such work a brief summary of the changes made to Python 1.6.1.\n\n4. CNRI is making Python 1.6.1 available to Licensee on an \"AS IS\" basis. CNRI\n MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE,\n BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY\n OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF\n PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.\n\n5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR\n ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF\n MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE\n THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n6. This License Agreement will automatically terminate upon a material breach of\n its terms and conditions.\n\n7. This License Agreement shall be governed by the federal intellectual property\n law of the United States, including without limitation the federal copyright\n law, and, to the extent such U.S. federal law does not apply, by the law of the\n Commonwealth of Virginia, excluding Virginia's conflict of law provisions.\n Notwithstanding the foregoing, with regard to derivative works based on Python\n 1.6.1 that incorporate non-separable material that was previously distributed\n under the GNU General Public License (GPL), the law of the Commonwealth of\n Virginia shall govern this License Agreement only as to issues arising under or\n with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in\n this License Agreement shall be deemed to create any relationship of agency,\n partnership, or joint venture between CNRI and Licensee. This License Agreement\n does not grant permission to use CNRI trademarks or trade name in a trademark\n sense to endorse or promote products or services of Licensee, or any third\n party.\n\n8. By clicking on the \"ACCEPT\" button where indicated, or by copying, installing\n or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and\n conditions of this License Agreement.\n\nCWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2\n\nCopyright © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The\nNetherlands. All rights reserved.\n\nPermission to use, copy, modify, and distribute this software and its\ndocumentation for any purpose and without fee is hereby granted, provided that\nthe above copyright notice appear in all copies and that both that copyright\nnotice and this permission notice appear in supporting documentation, and that\nthe name of Stichting Mathematisch Centrum or CWI not be used in advertising or\npublicity pertaining to distribution of the software without specific, written\nprior permission.\n\nSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS\nSOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO\nEVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT\nOR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,\nDATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS\nACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS\nSOFTWARE.\n\nLicenses and Acknowledgements for Incorporated Software\n\nThis section is an incomplete, but growing list of licenses and acknowledgements for third-party software incorporated in the Python distribution.\nMersenne Twister\n\nThe _random module includes code based on a download from http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html. The following are the verbatim comments from the original code:\n\nA C-program for MT19937, with initialization improved 2002/1/26.\nCoded by Takuji Nishimura and Makoto Matsumoto.\n\nBefore using, initialize the state by using init_genrand(seed)\nor init_by_array(init_key, key_length).\n\nCopyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions\nare met:\n\n 1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\n 3. The names of its contributors may not be used to endorse or promote\n products derived from this software without specific prior written\n permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR\nCONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\nEXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\nPROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\nPROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\nLIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\nNEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n\nAny feedback is very welcome.\nhttp://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html\nemail: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)\n\nSockets\n\nThe socket module uses the functions, getaddrinfo(), and getnameinfo(), which are coded in separate source files from the WIDE Project, http://www.wide.ad.jp/.\n\nCopyright (C) 1995, 1996, 1997, and 1998 WIDE Project.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions\nare met:\n1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n3. Neither the name of the project nor the names of its contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\nARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\nOR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\nHOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\nLIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\nOUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\nSUCH DAMAGE.\n\nFloating point exception control\n\nThe source for the fpectl module includes the following notice:\n\n ---------------------------------------------------------------------\n / Copyright (c) 1996. \\\n| The Regents of the University of California. |\n| All rights reserved. |\n| |\n| Permission to use, copy, modify, and distribute this software for |\n| any purpose without fee is hereby granted, provided that this en- |\n| tire notice is included in all copies of any software which is or |\n| includes a copy or modification of this software and in all |\n| copies of the supporting documentation for such software. |\n| |\n| This work was produced at the University of California, Lawrence |\n| Livermore National Laboratory under contract no. W-7405-ENG-48 |\n| between the U.S. Department of Energy and The Regents of the |\n| University of California for the operation of UC LLNL. |\n| |\n| DISCLAIMER |\n| |\n| This software was prepared as an account of work sponsored by an |\n| agency of the United States Government. Neither the United States |\n| Government nor the University of California nor any of their em- |\n| ployees, makes any warranty, express or implied, or assumes any |\n| liability or responsibility for the accuracy, completeness, or |\n| usefulness of any information, apparatus, product, or process |\n| disclosed, or represents that its use would not infringe |\n| privately-owned rights. Reference herein to any specific commer- |\n| cial products, process, or service by trade name, trademark, |\n| manufacturer, or otherwise, does not necessarily constitute or |\n| imply its endorsement, recommendation, or favoring by the United |\n| States Government or the University of California. The views and |\n| opinions of authors expressed herein do not necessarily state or |\n| reflect those of the United States Government or the University |\n| of California, and shall not be used for advertising or product |\n \\ endorsement purposes. /\n ---------------------------------------------------------------------\n\nAsynchronous socket services\n\nThe asynchat and asyncore modules contain the following notice:\n\nCopyright 1996 by Sam Rushing\n\n All Rights Reserved\n\nPermission to use, copy, modify, and distribute this software and\nits documentation for any purpose and without fee is hereby\ngranted, provided that the above copyright notice appear in all\ncopies and that both that copyright notice and this permission\nnotice appear in supporting documentation, and that the name of Sam\nRushing not be used in advertising or publicity pertaining to\ndistribution of the software without specific, written prior\npermission.\n\nSAM RUSHING DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,\nINCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN\nNO EVENT SHALL SAM RUSHING BE LIABLE FOR ANY SPECIAL, INDIRECT OR\nCONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS\nOF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,\nNEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN\nCONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\nCookie management\n\nThe http.cookies module contains the following notice:\n\nCopyright 2000 by Timothy O'Malley \n\n All Rights Reserved\n\nPermission to use, copy, modify, and distribute this software\nand its documentation for any purpose and without fee is hereby\ngranted, provided that the above copyright notice appear in all\ncopies and that both that copyright notice and this permission\nnotice appear in supporting documentation, and that the name of\nTimothy O'Malley not be used in advertising or publicity\npertaining to distribution of the software without specific, written\nprior permission.\n\nTimothy O'Malley DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS\nSOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\nAND FITNESS, IN NO EVENT SHALL Timothy O'Malley BE LIABLE FOR\nANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\nWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,\nWHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS\nACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\nPERFORMANCE OF THIS SOFTWARE.\n\nExecution tracing\n\nThe trace module contains the following notice:\n\nportions copyright 2001, Autonomous Zones Industries, Inc., all rights...\nerr... reserved and offered to the public under the terms of the\nPython 2.2 license.\nAuthor: Zooko O'Whielacronx\nhttp://zooko.com/\nmailto:zooko@zooko.com\n\nCopyright 2000, Mojam Media, Inc., all rights reserved.\nAuthor: Skip Montanaro\n\nCopyright 1999, Bioreason, Inc., all rights reserved.\nAuthor: Andrew Dalke\n\nCopyright 1995-1997, Automatrix, Inc., all rights reserved.\nAuthor: Skip Montanaro\n\nCopyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved.\n\n\nPermission to use, copy, modify, and distribute this Python software and\nits associated documentation for any purpose without fee is hereby\ngranted, provided that the above copyright notice appears in all copies,\nand that both that copyright notice and this permission notice appear in\nsupporting documentation, and that the name of neither Automatrix,\nBioreason or Mojam Media be used in advertising or publicity pertaining to\ndistribution of the software without specific, written prior permission.\n\nUUencode and UUdecode functions\n\nThe uu module contains the following notice:\n\nCopyright 1994 by Lance Ellinghouse\nCathedral City, California Republic, United States of America.\n All Rights Reserved\nPermission to use, copy, modify, and distribute this software and its\ndocumentation for any purpose and without fee is hereby granted,\nprovided that the above copyright notice appear in all copies and that\nboth that copyright notice and this permission notice appear in\nsupporting documentation, and that the name of Lance Ellinghouse\nnot be used in advertising or publicity pertaining to distribution\nof the software without specific, written prior permission.\nLANCE ELLINGHOUSE DISCLAIMS ALL WARRANTIES WITH REGARD TO\nTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\nFITNESS, IN NO EVENT SHALL LANCE ELLINGHOUSE CENTRUM BE LIABLE\nFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\nWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\nACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT\nOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\nModified by Jack Jansen, CWI, July 1995:\n- Use binascii module to do the actual line-by-line conversion\n between ascii and binary. This results in a 1000-fold speedup. The C\n version is still 5 times faster, though.\n- Arguments more compliant with Python standard\n\nXML Remote Procedure Calls\n\nThe xmlrpc.client module contains the following notice:\n\n The XML-RPC client interface is\n\nCopyright (c) 1999-2002 by Secret Labs AB\nCopyright (c) 1999-2002 by Fredrik Lundh\n\nBy obtaining, using, and/or copying this software and/or its\nassociated documentation, you agree that you have read, understood,\nand will comply with the following terms and conditions:\n\nPermission to use, copy, modify, and distribute this software and\nits associated documentation for any purpose and without fee is\nhereby granted, provided that the above copyright notice appears in\nall copies, and that both that copyright notice and this permission\nnotice appear in supporting documentation, and that the name of\nSecret Labs AB or the author not be used in advertising or publicity\npertaining to distribution of the software without specific, written\nprior permission.\n\nSECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD\nTO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-\nABILITY AND FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR\nBE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY\nDAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,\nWHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS\nACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE\nOF THIS SOFTWARE.\n\ntest_epoll\n\nThe test_epoll module contains the following notice:\n\nCopyright (c) 2001-2006 Twisted Matrix Laboratories.\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nSelect kqueue\n\nThe select module contains the following notice for the kqueue interface:\n\nCopyright (c) 2000 Doug White, 2006 James Knight, 2007 Christian Heimes\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions\nare met:\n1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\nARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\nOR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\nHOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\nLIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\nOUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\nSUCH DAMAGE.\n\nSipHash24\n\nThe file Python/pyhash.c contains Marek Majkowski’ implementation of Dan Bernstein’s SipHash24 algorithm. The contains the following note:\n\n\nCopyright (c) 2013 Marek Majkowski \n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\n\nOriginal location:\n https://github.com/majek/csiphash/\n\nSolution inspired by code from:\n Samuel Neves (supercop/crypto_auth/siphash24/little)\n djb (supercop/crypto_auth/siphash24/little2)\n Jean-Philippe Aumasson (https://131002.net/siphash/siphash24.c)\n\nstrtod and dtoa\n\nThe file Python/dtoa.c, which supplies C functions dtoa and strtod for conversion of C doubles to and from strings, is derived from the file of the same name by David M. Gay, currently available from http://www.netlib.org/fp/. The original file, as retrieved on March 16, 2009, contains the following copyright and licensing notice:\n\n/****************************************************************\n *\n * The author of this software is David M. Gay.\n *\n * Copyright (c) 1991, 2000, 2001 by Lucent Technologies.\n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose without fee is hereby granted, provided that this entire notice\n * is included in all copies of any software which is or includes a copy\n * or modification of this software and in all copies of the supporting\n * documentation for such software.\n *\n * THIS SOFTWARE IS BEING PROVIDED \"AS IS\", WITHOUT ANY EXPRESS OR IMPLIED\n * WARRANTY. IN PARTICULAR, NEITHER THE AUTHOR NOR LUCENT MAKES ANY\n * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY\n * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.\n *\n ***************************************************************/\n\nOpenSSL\n\nThe modules hashlib, posix, ssl, crypt use the OpenSSL library for added performance if made available by the operating system. Additionally, the Windows and Mac OS X installers for Python may include a copy of the OpenSSL libraries, so we include a copy of the OpenSSL license here:\n\n LICENSE ISSUES\n ==============\n\n The OpenSSL toolkit stays under a dual license, i.e. both the conditions of\n the OpenSSL License and the original SSLeay license apply to the toolkit.\n See below for the actual license texts. Actually both licenses are BSD-style\n Open Source licenses. In case of any license issues related to OpenSSL\n please contact openssl-core@openssl.org.\n\n OpenSSL License\n ---------------\n\n /* ====================================================================\n * Copyright (c) 1998-2008 The OpenSSL Project. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n *\n * 1. Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in\n * the documentation and/or other materials provided with the\n * distribution.\n *\n * 3. All advertising materials mentioning features or use of this\n * software must display the following acknowledgment:\n * \"This product includes software developed by the OpenSSL Project\n * for use in the OpenSSL Toolkit. (http://www.openssl.org/)\";\n *\n * 4. The names \"OpenSSL Toolkit\" and \"OpenSSL Project\" must not be used to\n * endorse or promote products derived from this software without\n * prior written permission. For written permission, please contact\n * openssl-core@openssl.org.\n *\n * 5. Products derived from this software may not be called \"OpenSSL\"\n * nor may \"OpenSSL\" appear in their names without prior written\n * permission of the OpenSSL Project.\n *\n * 6. Redistributions of any form whatsoever must retain the following\n * acknowledgment:\n * \"This product includes software developed by the OpenSSL Project\n * for use in the OpenSSL Toolkit (http://www.openssl.org/)\";\n *\n * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY\n * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR\n * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\n * OF THE POSSIBILITY OF SUCH DAMAGE.\n * ====================================================================\n *\n * This product includes cryptographic software written by Eric Young\n * (eay@cryptsoft.com). This product includes software written by Tim\n * Hudson (tjh@cryptsoft.com).\n *\n */\n\nOriginal SSLeay License\n-----------------------\n\n /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)\n * All rights reserved.\n *\n * This package is an SSL implementation written\n * by Eric Young (eay@cryptsoft.com).\n * The implementation was written so as to conform with Netscapes SSL.\n *\n * This library is free for commercial and non-commercial use as long as\n * the following conditions are aheared to. The following conditions\n * apply to all code found in this distribution, be it the RC4, RSA,\n * lhash, DES, etc., code; not just the SSL code. The SSL documentation\n * included with this distribution is covered by the same copyright terms\n * except that the holder is Tim Hudson (tjh@cryptsoft.com).\n *\n * Copyright remains Eric Young's, and as such any Copyright notices in\n * the code are not to be removed.\n * If this package is used in a product, Eric Young should be given attribution\n * as the author of the parts of the library used.\n * This can be in the form of a textual message at program startup or\n * in documentation (online or textual) provided with the package.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n * 1. Redistributions of source code must retain the copyright\n * notice, this list of conditions and the following disclaimer.\n * 2. Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * 3. All advertising materials mentioning features or use of this software\n * must display the following acknowledgement:\n * \"This product includes cryptographic software written by\n * Eric Young (eay@cryptsoft.com)\"\n * The word 'cryptographic' can be left out if the rouines from the library\n * being used are not cryptographic related :-).\n * 4. If you include any Windows specific code (or a derivative thereof) from\n * the apps directory (application code) you must include an acknowledgement:\n * \"This product includes software written by Tim Hudson (tjh@cryptsoft.com)\"\n *\n * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n * SUCH DAMAGE.\n *\n * The licence and distribution terms for any publically available version or\n * derivative of this code cannot be changed. i.e. this code cannot simply be\n * copied and put under another distribution licence\n * [including the GNU Public Licence.]\n */\n\nexpat\n\nThe pyexpat extension is built using an included copy of the expat sources unless the build is configured --with-system-expat:\n\nCopyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd\n and Clark Cooper\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be included\nin all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nlibffi\n\nThe _ctypes extension is built using an included copy of the libffi sources unless the build is configured --with-system-libffi:\n\nCopyright (c) 1996-2008 Red Hat, Inc and others.\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n``Software''), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be included\nin all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\nHOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\nWHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n\nzlib\n\nThe zlib extension is built using an included copy of the zlib sources if the zlib version found on the system is too old to be used for the build:\n\nCopyright (C) 1995-2011 Jean-loup Gailly and Mark Adler\n\nThis software is provided 'as-is', without any express or implied\nwarranty. In no event will the authors be held liable for any damages\narising from the use of this software.\n\nPermission is granted to anyone to use this software for any purpose,\nincluding commercial applications, and to alter it and redistribute it\nfreely, subject to the following restrictions:\n\n1. The origin of this software must not be misrepresented; you must not\n claim that you wrote the original software. If you use this software\n in a product, an acknowledgment in the product documentation would be\n appreciated but is not required.\n\n2. Altered source versions must be plainly marked as such, and must not be\n misrepresented as being the original software.\n\n3. This notice may not be removed or altered from any source distribution.\n\nJean-loup Gailly Mark Adler\njloup@gzip.org madler@alumni.caltech.edu\n\ncfuhash\n\nThe implementation of the hash table used by the tracemalloc is based on the cfuhash project:\n\nCopyright (c) 2005 Don Owens\nAll rights reserved.\n\nThis code is released under the BSD license:\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions\nare met:\n\n * Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n * Redistributions in binary form must reproduce the above\n copyright notice, this list of conditions and the following\n disclaimer in the documentation and/or other materials provided\n with the distribution.\n\n * Neither the name of the author nor the names of its\n contributors may be used to endorse or promote products derived\n from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS\nFOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE\nCOPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,\nINCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\nHOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\nSTRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\nARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\nOF THE POSSIBILITY OF SUCH DAMAGE.\n\nlibmpdec\n\nThe _decimal module is built using an included copy of the libmpdec library unless the build is configured --with-system-libmpdec:\n\nCopyright (c) 2008-2016 Stefan Krah. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions\nare met:\n\n1. Redistributions of source code must retain the above copyright\n notice, this list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\nARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\nOR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\nHOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\nLIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\nOUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\nSUCH DAMAGE.\n\n\n================================================================================\npybind11 2.5.0 (Provided under following license)\n================================================================================\n\nCopyright (c) 2016 Wenzel Jakob , All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this\n list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice,\n this list of conditions and the following disclaimer in the documentation\n and/or other materials provided with the distribution.\n\n3. Neither the name of the copyright holder nor the names of its contributors\n may be used to endorse or promote products derived from this software\n without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nPlease also refer to the file CONTRIBUTING.md, which clarifies licensing of\nexternal contributions to this project including patches, pull requests, etc.\n\n================================================================================\n\nresult (Provided under following license)\n================================================================================\n\nCopyright (C) 2015-2020 Danilo Bargen and contributors\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\nof the Software, and to permit persons to whom the Software is furnished to do\nso, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n================================================================================\n\nrequests 2.25.1 (Provided under following license)\n================================================================================\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n================================================================================\n\ntoml 0.10.2 (Provided under following license)\n================================================================================\nThe MIT License\n\nCopyright 2013-2019 William Pearson\nCopyright 2015-2016 Julien Enselme\nCopyright 2016 Google Inc.\nCopyright 2017 Samuel Vasko\nCopyright 2017 Nate Prewitt\nCopyright 2017 Jack Evans\nCopyright 2019 Filippo Broggini\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n================================================================================\n\npyyaml 5.3.1 (Provided under following license)\n================================================================================\n\nCopyright (c) 2017-2020 Ingy döt Net\nCopyright (c) 2006-2016 Kirill Simonov\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\nof the Software, and to permit persons to whom the Software is furnished to do\nso, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n================================================================================\n\npackaging 20.9 (Provided under following license)\n================================================================================\n\nThis software is made available under the terms of *either* of the licenses\nfound in LICENSE.APACHE or LICENSE.BSD. Contributions to this software is made\nunder the terms of *both* these licenses.\n\nApache 2.0\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\nBSD\n\nCopyright (c) Donald Stufft and individual contributors.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n 1. Redistributions of source code must retain the above copyright notice,\n this list of conditions and the following disclaimer.\n\n 2. Redistributions in binary form must reproduce the above copyright\n notice, this list of conditions and the following disclaimer in the\n documentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\nANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\nWARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n================================================================================\nurllib3 1.26.4 (Provided under following license)\n================================================================================\n\nMIT License\n\nCopyright (c) 2008-2020 Andrey Petrov and contributors (see CONTRIBUTORS.txt)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n================================================================================\n\nidna 2.6 (Provided under following license)\n================================================================================\n\nCopyright (c) 2013-2017, Kim Davies. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n Neither the name of the copyright holder nor the names of the contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nPortions of the codec implementation and unit tests are derived from the Python standard library, which carries the Python Software Foundation License:\n\n Copyright (c) 2001-2014 Python Software Foundation; All Rights Reserved\n\nPortions of the unit tests are derived from the Unicode standard, which is subject to the Unicode, Inc. License Agreement:\n\n Copyright (c) 1991-2014 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in .\n\n Permission is hereby granted, free of charge, to any person obtaining a copy of the Unicode data files and any associated documentation (the \"Data Files\") or Unicode software and any associated documentation (the \"Software\") to deal in the Data Files or Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Data Files or Software, and to permit persons to whom the Data Files or Software are furnished to do so, provided that\n\n (a) this copyright and permission notice appear with all copies of the Data Files or Software,\n\n (b) this copyright and permission notice appear in associated documentation, and\n\n (c) there is clear notice in each modified Data File or in the Software as well as in the documentation associated with the Data File(s) or Software that the data or software has been modified.\n\n THE DATA FILES AND SOFTWARE ARE PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE.\n\n Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in these Data Files or Software without prior written authorization of the copyright holder.\n\n================================================================================\n\ncertifi 2020.12.5 (Provided under following license)\n================================================================================\n\nThis packge contains a modified version of ca-bundle.crt:\n\nca-bundle.crt -- Bundle of CA Root Certificates\n\nCertificate data from Mozilla as of: Thu Nov 3 19:04:19 2011#\nThis is a bundle of X.509 certificates of public Certificate Authorities\n(CA). These were automatically extracted from Mozilla's root certificates\nfile (certdata.txt). This file can be found in the mozilla source tree:\nhttp://mxr.mozilla.org/mozilla/source/security/nss/lib/ckfw/builtins/certdata.txt?raw=1#\nIt contains the certificates in PEM format and therefore\ncan be directly used with curl / libcurl / php_curl, or with\nan Apache+mod_ssl webserver for SSL client authentication.\nJust configure this file as the SSLCACertificateFile.#\n\n***** BEGIN LICENSE BLOCK *****\nThis Source Code Form is subject to the terms of the Mozilla Public License,\nv. 2.0. If a copy of the MPL was not distributed with this file, You can obtain\none at http://mozilla.org/MPL/2.0/.\n\n***** END LICENSE BLOCK *****\n@(#) $RCSfile: certdata.txt,v $ $Revision: 1.80 $ $Date: 2011/11/03 15:11:58 $\n\n================================================================================\n\nchardet 3.0.4 (Provided under following license)\n================================================================================\n\n\t\t GNU LESSER GENERAL PUBLIC LICENSE\n\t\t Version 2.1, February 1999\n\n Copyright (C) 1991, 1999 Free Software Foundation, Inc.\n 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n[This is the first released version of the Lesser GPL. It also counts\n as the successor of the GNU Library Public License, version 2, hence\n the version number 2.1.]\n\n\t\t\t Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicenses are intended to guarantee your freedom to share and change\nfree software--to make sure the software is free for all its users.\n\n This license, the Lesser General Public License, applies to some\nspecially designated software packages--typically libraries--of the\nFree Software Foundation and other authors who decide to use it. You\ncan use it too, but we suggest you first think carefully about whether\nthis license or the ordinary General Public License is the better\nstrategy to use in any particular case, based on the explanations below.\n\n When we speak of free software, we are referring to freedom of use,\nnot price. Our General Public Licenses are designed to make sure that\nyou have the freedom to distribute copies of free software (and charge\nfor this service if you wish); that you receive source code or can get\nit if you want it; that you can change the software and use pieces of\nit in new free programs; and that you are informed that you can do\nthese things.\n\n To protect your rights, we need to make restrictions that forbid\ndistributors to deny you these rights or to ask you to surrender these\nrights. These restrictions translate to certain responsibilities for\nyou if you distribute copies of the library or if you modify it.\n\n For example, if you distribute copies of the library, whether gratis\nor for a fee, you must give the recipients all the rights that we gave\nyou. You must make sure that they, too, receive or can get the source\ncode. If you link other code with the library, you must provide\ncomplete object files to the recipients, so that they can relink them\nwith the library after making changes to the library and recompiling\nit. And you must show them these terms so they know their rights.\n\n We protect your rights with a two-step method: (1) we copyright the\nlibrary, and (2) we offer you this license, which gives you legal\npermission to copy, distribute and/or modify the library.\n\n To protect each distributor, we want to make it very clear that\nthere is no warranty for the free library. Also, if the library is\nmodified by someone else and passed on, the recipients should know\nthat what they have is not the original version, so that the original\nauthor's reputation will not be affected by problems that might be\nintroduced by others.\n\f\n Finally, software patents pose a constant threat to the existence of\nany free program. We wish to make sure that a company cannot\neffectively restrict the users of a free program by obtaining a\nrestrictive license from a patent holder. Therefore, we insist that\nany patent license obtained for a version of the library must be\nconsistent with the full freedom of use specified in this license.\n\n Most GNU software, including some libraries, is covered by the\nordinary GNU General Public License. This license, the GNU Lesser\nGeneral Public License, applies to certain designated libraries, and\nis quite different from the ordinary General Public License. We use\nthis license for certain libraries in order to permit linking those\nlibraries into non-free programs.\n\n When a program is linked with a library, whether statically or using\na shared library, the combination of the two is legally speaking a\ncombined work, a derivative of the original library. The ordinary\nGeneral Public License therefore permits such linking only if the\nentire combination fits its criteria of freedom. The Lesser General\nPublic License permits more lax criteria for linking other code with\nthe library.\n\n We call this license the \"Lesser\" General Public License because it\ndoes Less to protect the user's freedom than the ordinary General\nPublic License. It also provides other free software developers Less\nof an advantage over competing non-free programs. These disadvantages\nare the reason we use the ordinary General Public License for many\nlibraries. However, the Lesser license provides advantages in certain\nspecial circumstances.\n\n For example, on rare occasions, there may be a special need to\nencourage the widest possible use of a certain library, so that it becomes\na de-facto standard. To achieve this, non-free programs must be\nallowed to use the library. A more frequent case is that a free\nlibrary does the same job as widely used non-free libraries. In this\ncase, there is little to gain by limiting the free library to free\nsoftware only, so we use the Lesser General Public License.\n\n In other cases, permission to use a particular library in non-free\nprograms enables a greater number of people to use a large body of\nfree software. For example, permission to use the GNU C Library in\nnon-free programs enables many more people to use the whole GNU\noperating system, as well as its variant, the GNU/Linux operating\nsystem.\n\n Although the Lesser General Public License is Less protective of the\nusers' freedom, it does ensure that the user of a program that is\nlinked with the Library has the freedom and the wherewithal to run\nthat program using a modified version of the Library.\n\n The precise terms and conditions for copying, distribution and\nmodification follow. Pay close attention to the difference between a\n\"work based on the library\" and a \"work that uses the library\". The\nformer contains code derived from the library, whereas the latter must\nbe combined with the library in order to run.\n\f\n\t\t GNU LESSER GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License Agreement applies to any software library or other\nprogram which contains a notice placed by the copyright holder or\nother authorized party saying it may be distributed under the terms of\nthis Lesser General Public License (also called \"this License\").\nEach licensee is addressed as \"you\".\n\n A \"library\" means a collection of software functions and/or data\nprepared so as to be conveniently linked with application programs\n(which use some of those functions and data) to form executables.\n\n The \"Library\", below, refers to any such software library or work\nwhich has been distributed under these terms. A \"work based on the\nLibrary\" means either the Library or any derivative work under\ncopyright law: that is to say, a work containing the Library or a\nportion of it, either verbatim or with modifications and/or translated\nstraightforwardly into another language. (Hereinafter, translation is\nincluded without limitation in the term \"modification\".)\n\n \"Source code\" for a work means the preferred form of the work for\nmaking modifications to it. For a library, complete source code means\nall the source code for all modules it contains, plus any associated\ninterface definition files, plus the scripts used to control compilation\nand installation of the library.\n\n Activities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning a program using the Library is not restricted, and output from\nsuch a program is covered only if its contents constitute a work based\non the Library (independent of the use of the Library in a tool for\nwriting it). Whether that is true depends on what the Library does\nand what the program that uses the Library does.\n\n 1. You may copy and distribute verbatim copies of the Library's\ncomplete source code as you receive it, in any medium, provided that\nyou conspicuously and appropriately publish on each copy an\nappropriate copyright notice and disclaimer of warranty; keep intact\nall the notices that refer to this License and to the absence of any\nwarranty; and distribute a copy of this License along with the\nLibrary.\n\n You may charge a fee for the physical act of transferring a copy,\nand you may at your option offer warranty protection in exchange for a\nfee.\n\f\n 2. You may modify your copy or copies of the Library or any portion\nof it, thus forming a work based on the Library, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) The modified work must itself be a software library.\n\n b) You must cause the files modified to carry prominent notices\n stating that you changed the files and the date of any change.\n\n c) You must cause the whole of the work to be licensed at no\n charge to all third parties under the terms of this License.\n\n d) If a facility in the modified Library refers to a function or a\n table of data to be supplied by an application program that uses\n the facility, other than as an argument passed when the facility\n is invoked, then you must make a good faith effort to ensure that,\n in the event an application does not supply such function or\n table, the facility still operates, and performs whatever part of\n its purpose remains meaningful.\n\n (For example, a function in a library to compute square roots has\n a purpose that is entirely well-defined independent of the\n application. Therefore, Subsection 2d requires that any\n application-supplied function or table used by this function must\n be optional: if the application does not supply it, the square\n root function must still compute square roots.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Library,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Library, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote\nit.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Library.\n\nIn addition, mere aggregation of another work not based on the Library\nwith the Library (or with a work based on the Library) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may opt to apply the terms of the ordinary GNU General Public\nLicense instead of this License to a given copy of the Library. To do\nthis, you must alter all the notices that refer to this License, so\nthat they refer to the ordinary GNU General Public License, version 2,\ninstead of to this License. (If a newer version than version 2 of the\nordinary GNU General Public License has appeared, then you can specify\nthat version instead if you wish.) Do not make any other change in\nthese notices.\n\f\n Once this change is made in a given copy, it is irreversible for\nthat copy, so the ordinary GNU General Public License applies to all\nsubsequent copies and derivative works made from that copy.\n\n This option is useful when you wish to copy part of the code of\nthe Library into a program that is not a library.\n\n 4. You may copy and distribute the Library (or a portion or\nderivative of it, under Section 2) in object code or executable form\nunder the terms of Sections 1 and 2 above provided that you accompany\nit with the complete corresponding machine-readable source code, which\nmust be distributed under the terms of Sections 1 and 2 above on a\nmedium customarily used for software interchange.\n\n If distribution of object code is made by offering access to copy\nfrom a designated place, then offering equivalent access to copy the\nsource code from the same place satisfies the requirement to\ndistribute the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 5. A program that contains no derivative of any portion of the\nLibrary, but is designed to work with the Library by being compiled or\nlinked with it, is called a \"work that uses the Library\". Such a\nwork, in isolation, is not a derivative work of the Library, and\ntherefore falls outside the scope of this License.\n\n However, linking a \"work that uses the Library\" with the Library\ncreates an executable that is a derivative of the Library (because it\ncontains portions of the Library), rather than a \"work that uses the\nlibrary\". The executable is therefore covered by this License.\nSection 6 states terms for distribution of such executables.\n\n When a \"work that uses the Library\" uses material from a header file\nthat is part of the Library, the object code for the work may be a\nderivative work of the Library even though the source code is not.\nWhether this is true is especially significant if the work can be\nlinked without the Library, or if the work is itself a library. The\nthreshold for this to be true is not precisely defined by law.\n\n If such an object file uses only numerical parameters, data\nstructure layouts and accessors, and small macros and small inline\nfunctions (ten lines or less in length), then the use of the object\nfile is unrestricted, regardless of whether it is legally a derivative\nwork. (Executables containing this object code plus portions of the\nLibrary will still fall under Section 6.)\n\n Otherwise, if the work is a derivative of the Library, you may\ndistribute the object code for the work under the terms of Section 6.\nAny executables containing that work also fall under Section 6,\nwhether or not they are linked directly with the Library itself.\n\f\n 6. As an exception to the Sections above, you may also combine or\nlink a \"work that uses the Library\" with the Library to produce a\nwork containing portions of the Library, and distribute that work\nunder terms of your choice, provided that the terms permit\nmodification of the work for the customer's own use and reverse\nengineering for debugging such modifications.\n\n You must give prominent notice with each copy of the work that the\nLibrary is used in it and that the Library and its use are covered by\nthis License. You must supply a copy of this License. If the work\nduring execution displays copyright notices, you must include the\ncopyright notice for the Library among them, as well as a reference\ndirecting the user to the copy of this License. Also, you must do one\nof these things:\n\n a) Accompany the work with the complete corresponding\n machine-readable source code for the Library including whatever\n changes were used in the work (which must be distributed under\n Sections 1 and 2 above); and, if the work is an executable linked\n with the Library, with the complete machine-readable \"work that\n uses the Library\", as object code and/or source code, so that the\n user can modify the Library and then relink to produce a modified\n executable containing the modified Library. (It is understood\n that the user who changes the contents of definitions files in the\n Library will not necessarily be able to recompile the application\n to use the modified definitions.)\n\n b) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (1) uses at run time a\n copy of the library already present on the user's computer system,\n rather than copying library functions into the executable, and (2)\n will operate properly with a modified version of the library, if\n the user installs one, as long as the modified version is\n interface-compatible with the version that the work was made with.\n\n c) Accompany the work with a written offer, valid for at\n least three years, to give the same user the materials\n specified in Subsection 6a, above, for a charge no more\n than the cost of performing this distribution.\n\n d) If distribution of the work is made by offering access to copy\n from a designated place, offer equivalent access to copy the above\n specified materials from the same place.\n\n e) Verify that the user has already received a copy of these\n materials or that you have already sent this user a copy.\n\n For an executable, the required form of the \"work that uses the\nLibrary\" must include any data and utility programs needed for\nreproducing the executable from it. However, as a special exception,\nthe materials to be distributed need not include anything that is\nnormally distributed (in either source or binary form) with the major\ncomponents (compiler, kernel, and so on) of the operating system on\nwhich the executable runs, unless that component itself accompanies\nthe executable.\n\n It may happen that this requirement contradicts the license\nrestrictions of other proprietary libraries that do not normally\naccompany the operating system. Such a contradiction means you cannot\nuse both them and the Library together in an executable that you\ndistribute.\n\f\n 7. You may place library facilities that are a work based on the\nLibrary side-by-side in a single library together with other library\nfacilities not covered by this License, and distribute such a combined\nlibrary, provided that the separate distribution of the work based on\nthe Library and of the other library facilities is otherwise\npermitted, and provided that you do these two things:\n\n a) Accompany the combined library with a copy of the same work\n based on the Library, uncombined with any other library\n facilities. This must be distributed under the terms of the\n Sections above.\n\n b) Give prominent notice with the combined library of the fact\n that part of it is a work based on the Library, and explaining\n where to find the accompanying uncombined form of the same work.\n\n 8. You may not copy, modify, sublicense, link with, or distribute\nthe Library except as expressly provided under this License. Any\nattempt otherwise to copy, modify, sublicense, link with, or\ndistribute the Library is void, and will automatically terminate your\nrights under this License. However, parties who have received copies,\nor rights, from you under this License will not have their licenses\nterminated so long as such parties remain in full compliance.\n\n 9. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Library or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Library (or any work based on the\nLibrary), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Library or works based on it.\n\n 10. Each time you redistribute the Library (or any work based on the\nLibrary), the recipient automatically receives a license from the\noriginal licensor to copy, distribute, link with or modify the Library\nsubject to these terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties with\nthis License.\n\f\n 11. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Library at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Library by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Library.\n\nIf any portion of this section is held invalid or unenforceable under any\nparticular circumstance, the balance of the section is intended to apply,\nand the section as a whole is intended to apply in other circumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 12. If the distribution and/or use of the Library is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Library under this License may add\nan explicit geographical distribution limitation excluding those countries,\nso that distribution is permitted only in or among countries not thus\nexcluded. In such case, this License incorporates the limitation as if\nwritten in the body of this License.\n\n 13. The Free Software Foundation may publish revised and/or new\nversions of the Lesser General Public License from time to time.\nSuch new versions will be similar in spirit to the present version,\nbut may differ in detail to address new problems or concerns.\n\nEach version is given a distinguishing version number. If the Library\nspecifies a version number of this License which applies to it and\n\"any later version\", you have the option of following the terms and\nconditions either of that version or of any later version published by\nthe Free Software Foundation. If the Library does not specify a\nlicense version number, you may choose any version ever published by\nthe Free Software Foundation.\n\f\n 14. If you wish to incorporate parts of the Library into other free\nprograms whose distribution conditions are incompatible with these,\nwrite to the author to ask for permission. For software which is\ncopyrighted by the Free Software Foundation, write to the Free\nSoftware Foundation; we sometimes make exceptions for this. Our\ndecision will be guided by the two goals of preserving the free status\nof all derivatives of our free software and of promoting the sharing\nand reuse of software generally.\n\n\t\t\t NO WARRANTY\n\n 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\nWARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\nOTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY\nKIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\nLIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\nTHE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\nAND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\nFOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\nCONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\nLIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\nRENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\nFAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\nSUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\nDAMAGES.\n\n\t\t END OF TERMS AND CONDITIONS\n\f\n How to Apply These Terms to Your New Libraries\n\n If you develop a new library, and you want it to be of the greatest\npossible use to the public, we recommend making it free software that\neveryone can redistribute and change. You can do so by permitting\nredistribution under these terms (or, alternatively, under the terms of the\nordinary General Public License).\n\n To apply these terms, attach the following notices to the library. It is\nsafest to attach them to the start of each source file to most effectively\nconvey the exclusion of warranty; and each file should have at least the\n\"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation; either\n version 2.1 of the License, or (at your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, write to the Free Software\n Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n\nAlso add information on how to contact you by electronic and paper mail.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the library, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\n library `Frob' (a library for tweaking knobs) written by James Random Hacker.\n\n , 1 April 1990\n Ty Coon, President of Vice\n\nThat's all there is to it!\n\n================================================================================\n\nGLib (Provided under following license)\n================================================================================\n GNU LESSER GENERAL PUBLIC LICENSE\n Version 2.1, February 1999\n\n Copyright (C) 1991, 1999 Free Software Foundation, Inc.\n 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n[This is the first released version of the Lesser GPL. It also counts\n as the successor of the GNU Library Public License, version 2, hence\n the version number 2.1.]\n\n Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicenses are intended to guarantee your freedom to share and change\nfree software--to make sure the software is free for all its users.\n\n This license, the Lesser General Public License, applies to some\nspecially designated software packages--typically libraries--of the\nFree Software Foundation and other authors who decide to use it. You\ncan use it too, but we suggest you first think carefully about whether\nthis license or the ordinary General Public License is the better\nstrategy to use in any particular case, based on the explanations below.\n\n When we speak of free software, we are referring to freedom of use,\nnot price. Our General Public Licenses are designed to make sure that\nyou have the freedom to distribute copies of free software (and charge\nfor this service if you wish); that you receive source code or can get\nit if you want it; that you can change the software and use pieces of\nit in new free programs; and that you are informed that you can do\nthese things.\n\n To protect your rights, we need to make restrictions that forbid\ndistributors to deny you these rights or to ask you to surrender these\nrights. These restrictions translate to certain responsibilities for\nyou if you distribute copies of the library or if you modify it.\n\n For example, if you distribute copies of the library, whether gratis\nor for a fee, you must give the recipients all the rights that we gave\nyou. You must make sure that they, too, receive or can get the source\ncode. If you link other code with the library, you must provide\ncomplete object files to the recipients, so that they can relink them\nwith the library after making changes to the library and recompiling\nit. And you must show them these terms so they know their rights.\n\n We protect your rights with a two-step method: (1) we copyright the\nlibrary, and (2) we offer you this license, which gives you legal\npermission to copy, distribute and/or modify the library.\n\n To protect each distributor, we want to make it very clear that\nthere is no warranty for the free library. Also, if the library is\nmodified by someone else and passed on, the recipients should know\nthat what they have is not the original version, so that the original\nauthor's reputation will not be affected by problems that might be\nintroduced by others.\n\n Finally, software patents pose a constant threat to the existence of\nany free program. We wish to make sure that a company cannot\neffectively restrict the users of a free program by obtaining a\nrestrictive license from a patent holder. Therefore, we insist that\nany patent license obtained for a version of the library must be\nconsistent with the full freedom of use specified in this license.\n\n Most GNU software, including some libraries, is covered by the\nordinary GNU General Public License. This license, the GNU Lesser\nGeneral Public License, applies to certain designated libraries, and\nis quite different from the ordinary General Public License. We use\nthis license for certain libraries in order to permit linking those\nlibraries into non-free programs.\n\n When a program is linked with a library, whether statically or using\na shared library, the combination of the two is legally speaking a\ncombined work, a derivative of the original library. The ordinary\nGeneral Public License therefore permits such linking only if the\nentire combination fits its criteria of freedom. The Lesser General\nPublic License permits more lax criteria for linking other code with\nthe library.\n\n We call this license the \"Lesser\" General Public License because it\ndoes Less to protect the user's freedom than the ordinary General\nPublic License. It also provides other free software developers Less\nof an advantage over competing non-free programs. These disadvantages\nare the reason we use the ordinary General Public License for many\nlibraries. However, the Lesser license provides advantages in certain\nspecial circumstances.\n\n For example, on rare occasions, there may be a special need to\nencourage the widest possible use of a certain library, so that it becomes\na de-facto standard. To achieve this, non-free programs must be\nallowed to use the library. A more frequent case is that a free\nlibrary does the same job as widely used non-free libraries. In this\ncase, there is little to gain by limiting the free library to free\nsoftware only, so we use the Lesser General Public License.\n\n In other cases, permission to use a particular library in non-free\nprograms enables a greater number of people to use a large body of\nfree software. For example, permission to use the GNU C Library in\nnon-free programs enables many more people to use the whole GNU\noperating system, as well as its variant, the GNU/Linux operating\nsystem.\n\n Although the Lesser General Public License is Less protective of the\nusers' freedom, it does ensure that the user of a program that is\nlinked with the Library has the freedom and the wherewithal to run\nthat program using a modified version of the Library.\n\n The precise terms and conditions for copying, distribution and\nmodification follow. Pay close attention to the difference between a\n\"work based on the library\" and a \"work that uses the library\". The\nformer contains code derived from the library, whereas the latter must\nbe combined with the library in order to run.\n\n GNU LESSER GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License Agreement applies to any software library or other\nprogram which contains a notice placed by the copyright holder or\nother authorized party saying it may be distributed under the terms of\nthis Lesser General Public License (also called \"this License\").\nEach licensee is addressed as \"you\".\n\n A \"library\" means a collection of software functions and/or data\nprepared so as to be conveniently linked with application programs\n(which use some of those functions and data) to form executables.\n\n The \"Library\", below, refers to any such software library or work\nwhich has been distributed under these terms. A \"work based on the\nLibrary\" means either the Library or any derivative work under\ncopyright law: that is to say, a work containing the Library or a\nportion of it, either verbatim or with modifications and/or translated\nstraightforwardly into another language. (Hereinafter, translation is\nincluded without limitation in the term \"modification\".)\n\n \"Source code\" for a work means the preferred form of the work for\nmaking modifications to it. For a library, complete source code means\nall the source code for all modules it contains, plus any associated\ninterface definition files, plus the scripts used to control compilation\nand installation of the library.\n\n Activities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning a program using the Library is not restricted, and output from\nsuch a program is covered only if its contents constitute a work based\non the Library (independent of the use of the Library in a tool for\nwriting it). Whether that is true depends on what the Library does\nand what the program that uses the Library does.\n\n 1. You may copy and distribute verbatim copies of the Library's\ncomplete source code as you receive it, in any medium, provided that\nyou conspicuously and appropriately publish on each copy an\nappropriate copyright notice and disclaimer of warranty; keep intact\nall the notices that refer to this License and to the absence of any\nwarranty; and distribute a copy of this License along with the\nLibrary.\n\n You may charge a fee for the physical act of transferring a copy,\nand you may at your option offer warranty protection in exchange for a\nfee.\n\n 2. You may modify your copy or copies of the Library or any portion\nof it, thus forming a work based on the Library, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) The modified work must itself be a software library.\n\n b) You must cause the files modified to carry prominent notices\n stating that you changed the files and the date of any change.\n\n c) You must cause the whole of the work to be licensed at no\n charge to all third parties under the terms of this License.\n\n d) If a facility in the modified Library refers to a function or a\n table of data to be supplied by an application program that uses\n the facility, other than as an argument passed when the facility\n is invoked, then you must make a good faith effort to ensure that,\n in the event an application does not supply such function or\n table, the facility still operates, and performs whatever part of\n its purpose remains meaningful.\n\n (For example, a function in a library to compute square roots has\n a purpose that is entirely well-defined independent of the\n application. Therefore, Subsection 2d requires that any\n application-supplied function or table used by this function must\n be optional: if the application does not supply it, the square\n root function must still compute square roots.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Library,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Library, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote\nit.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Library.\n\nIn addition, mere aggregation of another work not based on the Library\nwith the Library (or with a work based on the Library) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may opt to apply the terms of the ordinary GNU General Public\nLicense instead of this License to a given copy of the Library. To do\nthis, you must alter all the notices that refer to this License, so\nthat they refer to the ordinary GNU General Public License, version 2,\ninstead of to this License. (If a newer version than version 2 of the\nordinary GNU General Public License has appeared, then you can specify\nthat version instead if you wish.) Do not make any other change in\nthese notices.\n\n Once this change is made in a given copy, it is irreversible for\nthat copy, so the ordinary GNU General Public License applies to all\nsubsequent copies and derivative works made from that copy.\n\n This option is useful when you wish to copy part of the code of\nthe Library into a program that is not a library.\n\n 4. You may copy and distribute the Library (or a portion or\nderivative of it, under Section 2) in object code or executable form\nunder the terms of Sections 1 and 2 above provided that you accompany\nit with the complete corresponding machine-readable source code, which\nmust be distributed under the terms of Sections 1 and 2 above on a\nmedium customarily used for software interchange.\n\n If distribution of object code is made by offering access to copy\nfrom a designated place, then offering equivalent access to copy the\nsource code from the same place satisfies the requirement to\ndistribute the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 5. A program that contains no derivative of any portion of the\nLibrary, but is designed to work with the Library by being compiled or\nlinked with it, is called a \"work that uses the Library\". Such a\nwork, in isolation, is not a derivative work of the Library, and\ntherefore falls outside the scope of this License.\n\n However, linking a \"work that uses the Library\" with the Library\ncreates an executable that is a derivative of the Library (because it\ncontains portions of the Library), rather than a \"work that uses the\nlibrary\". The executable is therefore covered by this License.\nSection 6 states terms for distribution of such executables.\n\n When a \"work that uses the Library\" uses material from a header file\nthat is part of the Library, the object code for the work may be a\nderivative work of the Library even though the source code is not.\nWhether this is true is especially significant if the work can be\nlinked without the Library, or if the work is itself a library. The\nthreshold for this to be true is not precisely defined by law.\n\n If such an object file uses only numerical parameters, data\nstructure layouts and accessors, and small macros and small inline\nfunctions (ten lines or less in length), then the use of the object\nfile is unrestricted, regardless of whether it is legally a derivative\nwork. (Executables containing this object code plus portions of the\nLibrary will still fall under Section 6.)\n\n Otherwise, if the work is a derivative of the Library, you may\ndistribute the object code for the work under the terms of Section 6.\nAny executables containing that work also fall under Section 6,\nwhether or not they are linked directly with the Library itself.\n\n 6. As an exception to the Sections above, you may also combine or\nlink a \"work that uses the Library\" with the Library to produce a\nwork containing portions of the Library, and distribute that work\nunder terms of your choice, provided that the terms permit\nmodification of the work for the customer's own use and reverse\nengineering for debugging such modifications.\n\n You must give prominent notice with each copy of the work that the\nLibrary is used in it and that the Library and its use are covered by\nthis License. You must supply a copy of this License. If the work\nduring execution displays copyright notices, you must include the\ncopyright notice for the Library among them, as well as a reference\ndirecting the user to the copy of this License. Also, you must do one\nof these things:\n\n a) Accompany the work with the complete corresponding\n machine-readable source code for the Library including whatever\n changes were used in the work (which must be distributed under\n Sections 1 and 2 above); and, if the work is an executable linked\n with the Library, with the complete machine-readable \"work that\n uses the Library\", as object code and/or source code, so that the\n user can modify the Library and then relink to produce a modified\n executable containing the modified Library. (It is understood\n that the user who changes the contents of definitions files in the\n Library will not necessarily be able to recompile the application\n to use the modified definitions.)\n\n b) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (1) uses at run time a\n copy of the library already present on the user's computer system,\n rather than copying library functions into the executable, and (2)\n will operate properly with a modified version of the library, if\n the user installs one, as long as the modified version is\n interface-compatible with the version that the work was made with.\n\n c) Accompany the work with a written offer, valid for at\n least three years, to give the same user the materials\n specified in Subsection 6a, above, for a charge no more\n than the cost of performing this distribution.\n\n d) If distribution of the work is made by offering access to copy\n from a designated place, offer equivalent access to copy the above\n specified materials from the same place.\n\n e) Verify that the user has already received a copy of these\n materials or that you have already sent this user a copy.\n\n For an executable, the required form of the \"work that uses the\nLibrary\" must include any data and utility programs needed for\nreproducing the executable from it. However, as a special exception,\nthe materials to be distributed need not include anything that is\nnormally distributed (in either source or binary form) with the major\ncomponents (compiler, kernel, and so on) of the operating system on\nwhich the executable runs, unless that component itself accompanies\nthe executable.\n\n It may happen that this requirement contradicts the license\nrestrictions of other proprietary libraries that do not normally\naccompany the operating system. Such a contradiction means you cannot\nuse both them and the Library together in an executable that you\ndistribute.\n\n 7. You may place library facilities that are a work based on the\nLibrary side-by-side in a single library together with other library\nfacilities not covered by this License, and distribute such a combined\nlibrary, provided that the separate distribution of the work based on\nthe Library and of the other library facilities is otherwise\npermitted, and provided that you do these two things:\n\n a) Accompany the combined library with a copy of the same work\n based on the Library, uncombined with any other library\n facilities. This must be distributed under the terms of the\n Sections above.\n\n b) Give prominent notice with the combined library of the fact\n that part of it is a work based on the Library, and explaining\n where to find the accompanying uncombined form of the same work.\n\n 8. You may not copy, modify, sublicense, link with, or distribute\nthe Library except as expressly provided under this License. Any\nattempt otherwise to copy, modify, sublicense, link with, or\ndistribute the Library is void, and will automatically terminate your\nrights under this License. However, parties who have received copies,\nor rights, from you under this License will not have their licenses\nterminated so long as such parties remain in full compliance.\n\n 9. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Library or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Library (or any work based on the\nLibrary), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Library or works based on it.\n\n 10. Each time you redistribute the Library (or any work based on the\nLibrary), the recipient automatically receives a license from the\noriginal licensor to copy, distribute, link with or modify the Library\nsubject to these terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties with\nthis License.\n\n 11. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Library at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Library by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Library.\n\nIf any portion of this section is held invalid or unenforceable under any\nparticular circumstance, the balance of the section is intended to apply,\nand the section as a whole is intended to apply in other circumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 12. If the distribution and/or use of the Library is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Library under this License may add\nan explicit geographical distribution limitation excluding those countries,\nso that distribution is permitted only in or among countries not thus\nexcluded. In such case, this License incorporates the limitation as if\nwritten in the body of this License.\n\n 13. The Free Software Foundation may publish revised and/or new\nversions of the Lesser General Public License from time to time.\nSuch new versions will be similar in spirit to the present version,\nbut may differ in detail to address new problems or concerns.\n\nEach version is given a distinguishing version number. If the Library\nspecifies a version number of this License which applies to it and\n\"any later version\", you have the option of following the terms and\nconditions either of that version or of any later version published by\nthe Free Software Foundation. If the Library does not specify a\nlicense version number, you may choose any version ever published by\nthe Free Software Foundation.\n\n 14. If you wish to incorporate parts of the Library into other free\nprograms whose distribution conditions are incompatible with these,\nwrite to the author to ask for permission. For software which is\ncopyrighted by the Free Software Foundation, write to the Free\nSoftware Foundation; we sometimes make exceptions for this. Our\ndecision will be guided by the two goals of preserving the free status\nof all derivatives of our free software and of promoting the sharing\nand reuse of software generally.\n\n NO WARRANTY\n\n 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\nWARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\nOTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY\nKIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\nLIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\nTHE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\nAND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\nFOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\nCONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\nLIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\nRENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\nFAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\nSUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\nDAMAGES.\n\n END OF TERMS AND CONDITIONS\n\n How to Apply These Terms to Your New Libraries\n\n If you develop a new library, and you want it to be of the greatest\npossible use to the public, we recommend making it free software that\neveryone can redistribute and change. You can do so by permitting\nredistribution under these terms (or, alternatively, under the terms of the\nordinary General Public License).\n\n To apply these terms, attach the following notices to the library. It is\nsafest to attach them to the start of each source file to most effectively\nconvey the exclusion of warranty; and each file should have at least the\n\"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Lesser General Public\n License as published by the Free Software Foundation; either\n version 2.1 of the License, or (at your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Lesser General Public License for more details.\n\n You should have received a copy of the GNU Lesser General Public\n License along with this library; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n\nAlso add information on how to contact you by electronic and paper mail.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the library, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\n library `Frob' (a library for tweaking knobs) written by James Random Hacker.\n\n , 1 April 1990\n Ty Coon, President of Vice\n\nThat's all there is to it!\n================================================================================\n\nGStreamer (Provided under following license)\n================================================================================\n\t\t GNU LIBRARY GENERAL PUBLIC LICENSE\n\t\t Version 2, June 1991\n\n Copyright (C) 1991 Free Software Foundation, Inc.\n 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n[This is the first released version of the library GPL. It is\n numbered 2 because it goes with version 2 of the ordinary GPL.]\n\n\t\t\t Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicenses are intended to guarantee your freedom to share and change\nfree software--to make sure the software is free for all its users.\n\n This license, the Library General Public License, applies to some\nspecially designated Free Software Foundation software, and to any\nother libraries whose authors decide to use it. You can use it for\nyour libraries, too.\n\n When we speak of free software, we are referring to freedom, not\nprice. Our General Public Licenses are designed to make sure that you\nhave the freedom to distribute copies of free software (and charge for\nthis service if you wish), that you receive source code or can get it\nif you want it, that you can change the software or use pieces of it\nin new free programs; and that you know you can do these things.\n\n To protect your rights, we need to make restrictions that forbid\nanyone to deny you these rights or to ask you to surrender the rights.\nThese restrictions translate to certain responsibilities for you if\nyou distribute copies of the library, or if you modify it.\n\n For example, if you distribute copies of the library, whether gratis\nor for a fee, you must give the recipients all the rights that we gave\nyou. You must make sure that they, too, receive or can get the source\ncode. If you link a program with the library, you must provide\ncomplete object files to the recipients so that they can relink them\nwith the library, after making changes to the library and recompiling\nit. And you must show them these terms so they know their rights.\n\n Our method of protecting your rights has two steps: (1) copyright\nthe library, and (2) offer you this license which gives you legal\npermission to copy, distribute and/or modify the library.\n\n Also, for each distributor's protection, we want to make certain\nthat everyone understands that there is no warranty for this free\nlibrary. If the library is modified by someone else and passed on, we\nwant its recipients to know that what they have is not the original\nversion, so that any problems introduced by others will not reflect on\nthe original authors' reputations.\n\n Finally, any free program is threatened constantly by software\npatents. We wish to avoid the danger that companies distributing free\nsoftware will individually obtain patent licenses, thus in effect\ntransforming the program into proprietary software. To prevent this,\nwe have made it clear that any patent must be licensed for everyone's\nfree use or not licensed at all.\n\n Most GNU software, including some libraries, is covered by the ordinary\nGNU General Public License, which was designed for utility programs. This\nlicense, the GNU Library General Public License, applies to certain\ndesignated libraries. This license is quite different from the ordinary\none; be sure to read it in full, and don't assume that anything in it is\nthe same as in the ordinary license.\n\n The reason we have a separate public license for some libraries is that\nthey blur the distinction we usually make between modifying or adding to a\nprogram and simply using it. Linking a program with a library, without\nchanging the library, is in some sense simply using the library, and is\nanalogous to running a utility program or application program. However, in\na textual and legal sense, the linked executable is a combined work, a\nderivative of the original library, and the ordinary General Public License\ntreats it as such.\n\n Because of this blurred distinction, using the ordinary General\nPublic License for libraries did not effectively promote software\nsharing, because most developers did not use the libraries. We\nconcluded that weaker conditions might promote sharing better.\n\n However, unrestricted linking of non-free programs would deprive the\nusers of those programs of all benefit from the free status of the\nlibraries themselves. This Library General Public License is intended to\npermit developers of non-free programs to use free libraries, while\npreserving your freedom as a user of such programs to change the free\nlibraries that are incorporated in them. (We have not seen how to achieve\nthis as regards changes in header files, but we have achieved it as regards\nchanges in the actual functions of the Library.) The hope is that this\nwill lead to faster development of free libraries.\n\n The precise terms and conditions for copying, distribution and\nmodification follow. Pay close attention to the difference between a\n\"work based on the library\" and a \"work that uses the library\". The\nformer contains code derived from the library, while the latter only\nworks together with the library.\n\n Note that it is possible for a library to be covered by the ordinary\nGeneral Public License rather than by this special one.\n\n\t\t GNU LIBRARY GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License Agreement applies to any software library which\ncontains a notice placed by the copyright holder or other authorized\nparty saying it may be distributed under the terms of this Library\nGeneral Public License (also called \"this License\"). Each licensee is\naddressed as \"you\".\n\n A \"library\" means a collection of software functions and/or data\nprepared so as to be conveniently linked with application programs\n(which use some of those functions and data) to form executables.\n\n The \"Library\", below, refers to any such software library or work\nwhich has been distributed under these terms. A \"work based on the\nLibrary\" means either the Library or any derivative work under\ncopyright law: that is to say, a work containing the Library or a\nportion of it, either verbatim or with modifications and/or translated\nstraightforwardly into another language. (Hereinafter, translation is\nincluded without limitation in the term \"modification\".)\n\n \"Source code\" for a work means the preferred form of the work for\nmaking modifications to it. For a library, complete source code means\nall the source code for all modules it contains, plus any associated\ninterface definition files, plus the scripts used to control compilation\nand installation of the library.\n\n Activities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning a program using the Library is not restricted, and output from\nsuch a program is covered only if its contents constitute a work based\non the Library (independent of the use of the Library in a tool for\nwriting it). Whether that is true depends on what the Library does\nand what the program that uses the Library does.\n\n 1. You may copy and distribute verbatim copies of the Library's\ncomplete source code as you receive it, in any medium, provided that\nyou conspicuously and appropriately publish on each copy an\nappropriate copyright notice and disclaimer of warranty; keep intact\nall the notices that refer to this License and to the absence of any\nwarranty; and distribute a copy of this License along with the\nLibrary.\n\n You may charge a fee for the physical act of transferring a copy,\nand you may at your option offer warranty protection in exchange for a\nfee.\n\n 2. You may modify your copy or copies of the Library or any portion\nof it, thus forming a work based on the Library, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) The modified work must itself be a software library.\n\n b) You must cause the files modified to carry prominent notices\n stating that you changed the files and the date of any change.\n\n c) You must cause the whole of the work to be licensed at no\n charge to all third parties under the terms of this License.\n\n d) If a facility in the modified Library refers to a function or a\n table of data to be supplied by an application program that uses\n the facility, other than as an argument passed when the facility\n is invoked, then you must make a good faith effort to ensure that,\n in the event an application does not supply such function or\n table, the facility still operates, and performs whatever part of\n its purpose remains meaningful.\n\n (For example, a function in a library to compute square roots has\n a purpose that is entirely well-defined independent of the\n application. Therefore, Subsection 2d requires that any\n application-supplied function or table used by this function must\n be optional: if the application does not supply it, the square\n root function must still compute square roots.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Library,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Library, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote\nit.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Library.\n\nIn addition, mere aggregation of another work not based on the Library\nwith the Library (or with a work based on the Library) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may opt to apply the terms of the ordinary GNU General Public\nLicense instead of this License to a given copy of the Library. To do\nthis, you must alter all the notices that refer to this License, so\nthat they refer to the ordinary GNU General Public License, version 2,\ninstead of to this License. (If a newer version than version 2 of the\nordinary GNU General Public License has appeared, then you can specify\nthat version instead if you wish.) Do not make any other change in\nthese notices.\n\n Once this change is made in a given copy, it is irreversible for\nthat copy, so the ordinary GNU General Public License applies to all\nsubsequent copies and derivative works made from that copy.\n\n This option is useful when you wish to copy part of the code of\nthe Library into a program that is not a library.\n\n 4. You may copy and distribute the Library (or a portion or\nderivative of it, under Section 2) in object code or executable form\nunder the terms of Sections 1 and 2 above provided that you accompany\nit with the complete corresponding machine-readable source code, which\nmust be distributed under the terms of Sections 1 and 2 above on a\nmedium customarily used for software interchange.\n\n If distribution of object code is made by offering access to copy\nfrom a designated place, then offering equivalent access to copy the\nsource code from the same place satisfies the requirement to\ndistribute the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 5. A program that contains no derivative of any portion of the\nLibrary, but is designed to work with the Library by being compiled or\nlinked with it, is called a \"work that uses the Library\". Such a\nwork, in isolation, is not a derivative work of the Library, and\ntherefore falls outside the scope of this License.\n\n However, linking a \"work that uses the Library\" with the Library\ncreates an executable that is a derivative of the Library (because it\ncontains portions of the Library), rather than a \"work that uses the\nlibrary\". The executable is therefore covered by this License.\nSection 6 states terms for distribution of such executables.\n\n When a \"work that uses the Library\" uses material from a header file\nthat is part of the Library, the object code for the work may be a\nderivative work of the Library even though the source code is not.\nWhether this is true is especially significant if the work can be\nlinked without the Library, or if the work is itself a library. The\nthreshold for this to be true is not precisely defined by law.\n\n If such an object file uses only numerical parameters, data\nstructure layouts and accessors, and small macros and small inline\nfunctions (ten lines or less in length), then the use of the object\nfile is unrestricted, regardless of whether it is legally a derivative\nwork. (Executables containing this object code plus portions of the\nLibrary will still fall under Section 6.)\n\n Otherwise, if the work is a derivative of the Library, you may\ndistribute the object code for the work under the terms of Section 6.\nAny executables containing that work also fall under Section 6,\nwhether or not they are linked directly with the Library itself.\n\n 6. As an exception to the Sections above, you may also compile or\nlink a \"work that uses the Library\" with the Library to produce a\nwork containing portions of the Library, and distribute that work\nunder terms of your choice, provided that the terms permit\nmodification of the work for the customer's own use and reverse\nengineering for debugging such modifications.\n\n You must give prominent notice with each copy of the work that the\nLibrary is used in it and that the Library and its use are covered by\nthis License. You must supply a copy of this License. If the work\nduring execution displays copyright notices, you must include the\ncopyright notice for the Library among them, as well as a reference\ndirecting the user to the copy of this License. Also, you must do one\nof these things:\n\n a) Accompany the work with the complete corresponding\n machine-readable source code for the Library including whatever\n changes were used in the work (which must be distributed under\n Sections 1 and 2 above); and, if the work is an executable linked\n with the Library, with the complete machine-readable \"work that\n uses the Library\", as object code and/or source code, so that the\n user can modify the Library and then relink to produce a modified\n executable containing the modified Library. (It is understood\n that the user who changes the contents of definitions files in the\n Library will not necessarily be able to recompile the application\n to use the modified definitions.)\n\n b) Accompany the work with a written offer, valid for at\n least three years, to give the same user the materials\n specified in Subsection 6a, above, for a charge no more\n than the cost of performing this distribution.\n\n c) If distribution of the work is made by offering access to copy\n from a designated place, offer equivalent access to copy the above\n specified materials from the same place.\n\n d) Verify that the user has already received a copy of these\n materials or that you have already sent this user a copy.\n\n For an executable, the required form of the \"work that uses the\nLibrary\" must include any data and utility programs needed for\nreproducing the executable from it. However, as a special exception,\nthe source code distributed need not include anything that is normally\ndistributed (in either source or binary form) with the major\ncomponents (compiler, kernel, and so on) of the operating system on\nwhich the executable runs, unless that component itself accompanies\nthe executable.\n\n It may happen that this requirement contradicts the license\nrestrictions of other proprietary libraries that do not normally\naccompany the operating system. Such a contradiction means you cannot\nuse both them and the Library together in an executable that you\ndistribute.\n\n 7. You may place library facilities that are a work based on the\nLibrary side-by-side in a single library together with other library\nfacilities not covered by this License, and distribute such a combined\nlibrary, provided that the separate distribution of the work based on\nthe Library and of the other library facilities is otherwise\npermitted, and provided that you do these two things:\n\n a) Accompany the combined library with a copy of the same work\n based on the Library, uncombined with any other library\n facilities. This must be distributed under the terms of the\n Sections above.\n\n b) Give prominent notice with the combined library of the fact\n that part of it is a work based on the Library, and explaining\n where to find the accompanying uncombined form of the same work.\n\n 8. You may not copy, modify, sublicense, link with, or distribute\nthe Library except as expressly provided under this License. Any\nattempt otherwise to copy, modify, sublicense, link with, or\ndistribute the Library is void, and will automatically terminate your\nrights under this License. However, parties who have received copies,\nor rights, from you under this License will not have their licenses\nterminated so long as such parties remain in full compliance.\n\n 9. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Library or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Library (or any work based on the\nLibrary), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Library or works based on it.\n\n 10. Each time you redistribute the Library (or any work based on the\nLibrary), the recipient automatically receives a license from the\noriginal licensor to copy, distribute, link with or modify the Library\nsubject to these terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties to\nthis License.\n\n 11. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Library at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Library by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Library.\n\nIf any portion of this section is held invalid or unenforceable under any\nparticular circumstance, the balance of the section is intended to apply,\nand the section as a whole is intended to apply in other circumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 12. If the distribution and/or use of the Library is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Library under this License may add\nan explicit geographical distribution limitation excluding those countries,\nso that distribution is permitted only in or among countries not thus\nexcluded. In such case, this License incorporates the limitation as if\nwritten in the body of this License.\n\n 13. The Free Software Foundation may publish revised and/or new\nversions of the Library General Public License from time to time.\nSuch new versions will be similar in spirit to the present version,\nbut may differ in detail to address new problems or concerns.\n\nEach version is given a distinguishing version number. If the Library\nspecifies a version number of this License which applies to it and\n\"any later version\", you have the option of following the terms and\nconditions either of that version or of any later version published by\nthe Free Software Foundation. If the Library does not specify a\nlicense version number, you may choose any version ever published by\nthe Free Software Foundation.\n\n 14. If you wish to incorporate parts of the Library into other free\nprograms whose distribution conditions are incompatible with these,\nwrite to the author to ask for permission. For software which is\ncopyrighted by the Free Software Foundation, write to the Free\nSoftware Foundation; we sometimes make exceptions for this. Our\ndecision will be guided by the two goals of preserving the free status\nof all derivatives of our free software and of promoting the sharing\nand reuse of software generally.\n\n\t\t\t NO WARRANTY\n\n 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\nWARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\nOTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY\nKIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\nLIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\nTHE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\nAND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\nFOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\nCONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\nLIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\nRENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\nFAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\nSUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\nDAMAGES.\n\n\t\t END OF TERMS AND CONDITIONS\n\n Appendix: How to Apply These Terms to Your New Libraries\n\n If you develop a new library, and you want it to be of the greatest\npossible use to the public, we recommend making it free software that\neveryone can redistribute and change. You can do so by permitting\nredistribution under these terms (or, alternatively, under the terms of the\nordinary General Public License).\n\n To apply these terms, attach the following notices to the library. It is\nsafest to attach them to the start of each source file to most effectively\nconvey the exclusion of warranty; and each file should have at least the\n\"copyright\" line and a pointer to where the full notice is found.\n\n \n Copyright (C) \n\n This library is free software; you can redistribute it and/or\n modify it under the terms of the GNU Library General Public\n License as published by the Free Software Foundation; either\n version 2 of the License, or (at your option) any later version.\n\n This library is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n Library General Public License for more details.\n\n You should have received a copy of the GNU Library General Public\n License along with this library; if not, write to the Free\n Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.\n\nAlso add information on how to contact you by electronic and paper mail.\n\nYou should also get your employer (if you work as a programmer) or your\nschool, if any, to sign a \"copyright disclaimer\" for the library, if\nnecessary. Here is a sample; alter the names:\n\n Yoyodyne, Inc., hereby disclaims all copyright interest in the\n library `Frob' (a library for tweaking knobs) written by James Random Hacker.\n\n , 1 April 1990\n Ty Coon, President of Vice\n\nThat's all there is to it!\n================================================================================\n\ndocker 4.4.1 (Provided under following license)\n===============================================================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n Copyright 2016 Docker, Inc.\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n================================================================================\n\njinja 2.11.2 (Provided under following license)\n===============================================================================\n\nCopyright 2007 Pallets\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n================================================================================\n\nmarkupsafe 1.1.1 (Provided under following license)\n===============================================================================\n\nCopyright 2010 Pallets\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n================================================================================\n\nurllib3 1.26.2 (Provided under following license)\n===============================================================================\n\nMIT License\n\nCopyright (c) 2008-2020 Andrey Petrov and contributors (see CONTRIBUTORS.txt)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n================================================================================\n\npyyaml 5.3.1 (Provided under following license)\n===============================================================================\n\nCopyright (c) 2017-2021 Ingy döt Net\nCopyright (c) 2006-2016 Kirill Simonov\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\nof the Software, and to permit persons to whom the Software is furnished to do\nso, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n================================================================================\n\ntyping 3.7.4.3 (Provided under following license)\n===============================================================================\n\nA. HISTORY OF THE SOFTWARE\n==========================\n\nPython was created in the early 1990s by Guido van Rossum at Stichting\nMathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands\nas a successor of a language called ABC. Guido remains Python's\nprincipal author, although it includes many contributions from others.\n\nIn 1995, Guido continued his work on Python at the Corporation for\nNational Research Initiatives (CNRI, see http://www.cnri.reston.va.us)\nin Reston, Virginia where he released several versions of the\nsoftware.\n\nIn May 2000, Guido and the Python core development team moved to\nBeOpen.com to form the BeOpen PythonLabs team. In October of the same\nyear, the PythonLabs team moved to Digital Creations (now Zope\nCorporation, see http://www.zope.com). In 2001, the Python Software\nFoundation (PSF, see http://www.python.org/psf/) was formed, a\nnon-profit organization created specifically to own Python-related\nIntellectual Property. Zope Corporation is a sponsoring member of\nthe PSF.\n\nAll Python releases are Open Source (see http://www.opensource.org for\nthe Open Source Definition). Historically, most, but not all, Python\nreleases have also been GPL-compatible; the table below summarizes\nthe various releases.\n\n Release Derived Year Owner GPL-\n from compatible? (1)\n\n 0.9.0 thru 1.2 1991-1995 CWI yes\n 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes\n 1.6 1.5.2 2000 CNRI no\n 2.0 1.6 2000 BeOpen.com no\n 1.6.1 1.6 2001 CNRI yes (2)\n 2.1 2.0+1.6.1 2001 PSF no\n 2.0.1 2.0+1.6.1 2001 PSF yes\n 2.1.1 2.1+2.0.1 2001 PSF yes\n 2.1.2 2.1.1 2002 PSF yes\n 2.1.3 2.1.2 2002 PSF yes\n 2.2 and above 2.1.1 2001-now PSF yes\n\nFootnotes:\n\n(1) GPL-compatible doesn't mean that we're distributing Python under\n the GPL. All Python licenses, unlike the GPL, let you distribute\n a modified version without making your changes open source. The\n GPL-compatible licenses make it possible to combine Python with\n other software that is released under the GPL; the others don't.\n\n(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,\n because its license has a choice of law clause. According to\n CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1\n is \"not incompatible\" with the GPL.\n\nThanks to the many outside volunteers who have worked under Guido's\ndirection to make these releases possible.\n\n\nB. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON\n===============================================================\n\nPYTHON SOFTWARE FOUNDATION LICENSE VERSION 2\n--------------------------------------------\n\n1. This LICENSE AGREEMENT is between the Python Software Foundation\n(\"PSF\"), and the Individual or Organization (\"Licensee\") accessing and\notherwise using this software (\"Python\") in source or binary form and\nits associated documentation.\n\n2. Subject to the terms and conditions of this License Agreement, PSF hereby\ngrants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,\nanalyze, test, perform and/or display publicly, prepare derivative works,\ndistribute, and otherwise use Python alone or in any derivative version,\nprovided, however, that PSF's License Agreement and PSF's notice of copyright,\ni.e., \"Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,\n2011, 2012, 2013, 2014 Python Software Foundation; All Rights Reserved\" are\nretained in Python alone or in any derivative version prepared by Licensee.\n\n3. In the event Licensee prepares a derivative work that is based on\nor incorporates Python or any part thereof, and wants to make\nthe derivative work available to others as provided herein, then\nLicensee hereby agrees to include in any such work a brief summary of\nthe changes made to Python.\n\n4. PSF is making Python available to Licensee on an \"AS IS\"\nbasis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR\nIMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND\nDISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS\nFOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT\nINFRINGE ANY THIRD PARTY RIGHTS.\n\n5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON\nFOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS\nA RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,\nOR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n6. This License Agreement will automatically terminate upon a material\nbreach of its terms and conditions.\n\n7. Nothing in this License Agreement shall be deemed to create any\nrelationship of agency, partnership, or joint venture between PSF and\nLicensee. This License Agreement does not grant permission to use PSF\ntrademarks or trade name in a trademark sense to endorse or promote\nproducts or services of Licensee, or any third party.\n\n8. By copying, installing or otherwise using Python, Licensee\nagrees to be bound by the terms and conditions of this License\nAgreement.\n\n\nBEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0\n-------------------------------------------\n\nBEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1\n\n1. This LICENSE AGREEMENT is between BeOpen.com (\"BeOpen\"), having an\noffice at 160 Saratoga Avenue, Santa Clara, CA 95051, and the\nIndividual or Organization (\"Licensee\") accessing and otherwise using\nthis software in source or binary form and its associated\ndocumentation (\"the Software\").\n\n2. Subject to the terms and conditions of this BeOpen Python License\nAgreement, BeOpen hereby grants Licensee a non-exclusive,\nroyalty-free, world-wide license to reproduce, analyze, test, perform\nand/or display publicly, prepare derivative works, distribute, and\notherwise use the Software alone or in any derivative version,\nprovided, however, that the BeOpen Python License is retained in the\nSoftware, alone or in any derivative version prepared by Licensee.\n\n3. BeOpen is making the Software available to Licensee on an \"AS IS\"\nbasis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR\nIMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND\nDISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS\nFOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT\nINFRINGE ANY THIRD PARTY RIGHTS.\n\n4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE\nSOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS\nAS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY\nDERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n5. This License Agreement will automatically terminate upon a material\nbreach of its terms and conditions.\n\n6. This License Agreement shall be governed by and interpreted in all\nrespects by the law of the State of California, excluding conflict of\nlaw provisions. Nothing in this License Agreement shall be deemed to\ncreate any relationship of agency, partnership, or joint venture\nbetween BeOpen and Licensee. This License Agreement does not grant\npermission to use BeOpen trademarks or trade names in a trademark\nsense to endorse or promote products or services of Licensee, or any\nthird party. As an exception, the \"BeOpen Python\" logos available at\nhttp://www.pythonlabs.com/logos.html may be used according to the\npermissions granted on that web page.\n\n7. By copying, installing or otherwise using the software, Licensee\nagrees to be bound by the terms and conditions of this License\nAgreement.\n\n\nCNRI LICENSE AGREEMENT FOR PYTHON 1.6.1\n---------------------------------------\n\n1. This LICENSE AGREEMENT is between the Corporation for National\nResearch Initiatives, having an office at 1895 Preston White Drive,\nReston, VA 20191 (\"CNRI\"), and the Individual or Organization\n(\"Licensee\") accessing and otherwise using Python 1.6.1 software in\nsource or binary form and its associated documentation.\n\n2. Subject to the terms and conditions of this License Agreement, CNRI\nhereby grants Licensee a nonexclusive, royalty-free, world-wide\nlicense to reproduce, analyze, test, perform and/or display publicly,\nprepare derivative works, distribute, and otherwise use Python 1.6.1\nalone or in any derivative version, provided, however, that CNRI's\nLicense Agreement and CNRI's notice of copyright, i.e., \"Copyright (c)\n1995-2001 Corporation for National Research Initiatives; All Rights\nReserved\" are retained in Python 1.6.1 alone or in any derivative\nversion prepared by Licensee. Alternately, in lieu of CNRI's License\nAgreement, Licensee may substitute the following text (omitting the\nquotes): \"Python 1.6.1 is made available subject to the terms and\nconditions in CNRI's License Agreement. This Agreement together with\nPython 1.6.1 may be located on the Internet using the following\nunique, persistent identifier (known as a handle): 1895.22/1013. This\nAgreement may also be obtained from a proxy server on the Internet\nusing the following URL: http://hdl.handle.net/1895.22/1013\".\n\n3. In the event Licensee prepares a derivative work that is based on\nor incorporates Python 1.6.1 or any part thereof, and wants to make\nthe derivative work available to others as provided herein, then\nLicensee hereby agrees to include in any such work a brief summary of\nthe changes made to Python 1.6.1.\n\n4. CNRI is making Python 1.6.1 available to Licensee on an \"AS IS\"\nbasis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR\nIMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND\nDISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS\nFOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT\nINFRINGE ANY THIRD PARTY RIGHTS.\n\n5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON\n1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS\nA RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,\nOR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n\n6. This License Agreement will automatically terminate upon a material\nbreach of its terms and conditions.\n\n7. This License Agreement shall be governed by the federal\nintellectual property law of the United States, including without\nlimitation the federal copyright law, and, to the extent such\nU.S. federal law does not apply, by the law of the Commonwealth of\nVirginia, excluding Virginia's conflict of law provisions.\nNotwithstanding the foregoing, with regard to derivative works based\non Python 1.6.1 that incorporate non-separable material that was\npreviously distributed under the GNU General Public License (GPL), the\nlaw of the Commonwealth of Virginia shall govern this License\nAgreement only as to issues arising under or with respect to\nParagraphs 4, 5, and 7 of this License Agreement. Nothing in this\nLicense Agreement shall be deemed to create any relationship of\nagency, partnership, or joint venture between CNRI and Licensee. This\nLicense Agreement does not grant permission to use CNRI trademarks or\ntrade name in a trademark sense to endorse or promote products or\nservices of Licensee, or any third party.\n\n8. By clicking on the \"ACCEPT\" button where indicated, or by copying,\ninstalling or otherwise using Python 1.6.1, Licensee agrees to be\nbound by the terms and conditions of this License Agreement.\n\n ACCEPT\n\n\nCWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2\n--------------------------------------------------\n\nCopyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,\nThe Netherlands. All rights reserved.\n\nPermission to use, copy, modify, and distribute this software and its\ndocumentation for any purpose and without fee is hereby granted,\nprovided that the above copyright notice appear in all copies and that\nboth that copyright notice and this permission notice appear in\nsupporting documentation, and that the name of Stichting Mathematisch\nCentrum or CWI not be used in advertising or publicity pertaining to\ndistribution of the software without specific, written prior\npermission.\n\nSTICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO\nTHIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\nFITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE\nFOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\nWHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\nACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT\nOF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\n================================================================================\n\nyaml-cpp 0.6.3 (Provided under following license)\n===============================================================================\n\nCopyright (c) 2008-2015 Jesse Beder.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n================================================================================\n\ngflags 2.2.1 (Provided under following license)\n===============================================================================\n\nCopyright (c) 2006, Google Inc.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n================================================================================\n\ngtest 1.8.0 (Provided under following license)\n===============================================================================\nCopyright 2008, Google Inc.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n================================================================================\n\nrules_python 0.1.0 (Provided under following license)\n===============================================================================\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"{}\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright {yyyy} {name of copyright owner}\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n================================================================================\n\nDCMI specification (Provided under following license)\n===============================================================================\n\n\nCreative Commons Attribution 4.0 International Public License\n\nBy exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution 4.0 International Public License (\"Public License\"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions.\n\nSection 1 – Definitions.\n\n Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image.\n Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License.\n Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights.\n Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements.\n Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material.\n Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License.\n Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license.\n Licensor means the individual(s) or entity(ies) granting rights under this Public License.\n Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them.\n Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world.\n You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning.\n\nSection 2 – Scope.\n\n License grant.\n Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to:\n reproduce and Share the Licensed Material, in whole or in part; and\n produce, reproduce, and Share Adapted Material.\n Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions.\n Term. The term of this Public License is specified in Section 6(a).\n Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material.\n Downstream recipients.\n Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License.\n No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material.\n No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i).\n\n Other rights.\n Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise.\n Patent and trademark rights are not licensed under this Public License.\n To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties.\n\nSection 3 – License Conditions.\n\nYour exercise of the Licensed Rights is expressly made subject to the following conditions.\n\n Attribution.\n\n If You Share the Licensed Material (including in modified form), You must:\n retain the following if it is supplied by the Licensor with the Licensed Material:\n identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated);\n a copyright notice;\n a notice that refers to this Public License;\n a notice that refers to the disclaimer of warranties;\n a URI or hyperlink to the Licensed Material to the extent reasonably practicable;\n indicate if You modified the Licensed Material and retain an indication of any previous modifications; and\n indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License.\n You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information.\n If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable.\n If You Share Adapted Material You produce, the Adapter's License You apply must not prevent recipients of the Adapted Material from complying with this Public License.\n\nSection 4 – Sui Generis Database Rights.\n\nWhere the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material:\n\n for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database;\n if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and\n You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database.\n\nFor the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights.\n\nSection 5 – Disclaimer of Warranties and Limitation of Liability.\n\n Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You.\n To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You.\n\n The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability.\n\nSection 6 – Term and Termination.\n\n This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically.\n\n Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates:\n automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or\n upon express reinstatement by the Licensor.\n For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License.\n For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License.\n Sections 1, 5, 6, 7, and 8 survive termination of this Public License.\n\nSection 7 – Other Terms and Conditions.\n\n The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed.\n Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License.\n\nSection 8 – Interpretation.\n\n For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License.\n To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions.\n No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor.\n Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority.\n\n===============================================================================\n\nbreakpad (Provided under following license)\n===============================================================================\n\nCopyright (c) 2006, Google Inc.\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n--------------------------------------------------------------------\n\nCopyright 2001-2004 Unicode, Inc.\n\nDisclaimer\n\nThis source code is provided as is by Unicode, Inc. No claims are\nmade as to fitness for any particular purpose. No warranties of any\nkind are expressed or implied. The recipient agrees to determine\napplicability of information provided. If this file has been\npurchased on magnetic or optical media from Unicode, Inc., the\nsole remedy for any claim will be exchange of defective media\nwithin 90 days of receipt.\n\nLimitations on Rights to Redistribute This Code\n\nUnicode, Inc. hereby grants the right to freely use the information\nsupplied in this file in the creation of products supporting the\nUnicode Standard, and to make copies of this file in any form\nfor internal or external distribution as long as this notice\nremains attached.\n\n================================================================================\n\nlinux-syscall-support (lss) (Provided under following license)\n===============================================================================\n\nCopyright (c) 2005-2011, Google Inc.\nAll rights reserved.\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n================================================================================\n\nbazel skylib 1.0.2 (Provided under following license)\n================================================================================\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n================================================================================\n\nnlohmann-json 3.10.4 (Provided under following license)\n================================================================================\nMIT License\n\nCopyright (c) 2013-2021 Niels Lohmann\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n================================================================================\n\nurwid 2.1.2 (Provided under following license)\n================================================================================\n GNU LESSER GENERAL PUBLIC LICENSE\n\t\t Version 2.1, February 1999\n\n Copyright (C) 1991, 1999 Free Software Foundation, Inc.\n 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n[This is the first released version of the Lesser GPL. It also counts\n as the successor of the GNU Library Public License, version 2, hence\n the version number 2.1.]\n\n\t\t\t Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicenses are intended to guarantee your freedom to share and change\nfree software--to make sure the software is free for all its users.\n\n This license, the Lesser General Public License, applies to some\nspecially designated software packages--typically libraries--of the\nFree Software Foundation and other authors who decide to use it. You\ncan use it too, but we suggest you first think carefully about whether\nthis license or the ordinary General Public License is the better\nstrategy to use in any particular case, based on the explanations below.\n\n When we speak of free software, we are referring to freedom of use,\nnot price. Our General Public Licenses are designed to make sure that\nyou have the freedom to distribute copies of free software (and charge\nfor this service if you wish); that you receive source code or can get\nit if you want it; that you can change the software and use pieces of\nit in new free programs; and that you are informed that you can do\nthese things.\n\n To protect your rights, we need to make restrictions that forbid\ndistributors to deny you these rights or to ask you to surrender these\nrights. These restrictions translate to certain responsibilities for\nyou if you distribute copies of the library or if you modify it.\n\n For example, if you distribute copies of the library, whether gratis\nor for a fee, you must give the recipients all the rights that we gave\nyou. You must make sure that they, too, receive or can get the source\ncode. If you link other code with the library, you must provide\ncomplete object files to the recipients, so that they can relink them\nwith the library after making changes to the library and recompiling\nit. And you must show them these terms so they know their rights.\n\n We protect your rights with a two-step method: (1) we copyright the\nlibrary, and (2) we offer you this license, which gives you legal\npermission to copy, distribute and/or modify the library.\n\n To protect each distributor, we want to make it very clear that\nthere is no warranty for the free library. Also, if the library is\nmodified by someone else and passed on, the recipients should know\nthat what they have is not the original version, so that the original\nauthor's reputation will not be affected by problems that might be\nintroduced by others.\n\f\n Finally, software patents pose a constant threat to the existence of\nany free program. We wish to make sure that a company cannot\neffectively restrict the users of a free program by obtaining a\nrestrictive license from a patent holder. Therefore, we insist that\nany patent license obtained for a version of the library must be\nconsistent with the full freedom of use specified in this license.\n\n Most GNU software, including some libraries, is covered by the\nordinary GNU General Public License. This license, the GNU Lesser\nGeneral Public License, applies to certain designated libraries, and\nis quite different from the ordinary General Public License. We use\nthis license for certain libraries in order to permit linking those\nlibraries into non-free programs.\n\n When a program is linked with a library, whether statically or using\na shared library, the combination of the two is legally speaking a\ncombined work, a derivative of the original library. The ordinary\nGeneral Public License therefore permits such linking only if the\nentire combination fits its criteria of freedom. The Lesser General\nPublic License permits more lax criteria for linking other code with\nthe library.\n\n We call this license the \"Lesser\" General Public License because it\ndoes Less to protect the user's freedom than the ordinary General\nPublic License. It also provides other free software developers Less\nof an advantage over competing non-free programs. These disadvantages\nare the reason we use the ordinary General Public License for many\nlibraries. However, the Lesser license provides advantages in certain\nspecial circumstances.\n\n For example, on rare occasions, there may be a special need to\nencourage the widest possible use of a certain library, so that it becomes\na de-facto standard. To achieve this, non-free programs must be\nallowed to use the library. A more frequent case is that a free\nlibrary does the same job as widely used non-free libraries. In this\ncase, there is little to gain by limiting the free library to free\nsoftware only, so we use the Lesser General Public License.\n\n In other cases, permission to use a particular library in non-free\nprograms enables a greater number of people to use a large body of\nfree software. For example, permission to use the GNU C Library in\nnon-free programs enables many more people to use the whole GNU\noperating system, as well as its variant, the GNU/Linux operating\nsystem.\n\n Although the Lesser General Public License is Less protective of the\nusers' freedom, it does ensure that the user of a program that is\nlinked with the Library has the freedom and the wherewithal to run\nthat program using a modified version of the Library.\n\n The precise terms and conditions for copying, distribution and\nmodification follow. Pay close attention to the difference between a\n\"work based on the library\" and a \"work that uses the library\". The\nformer contains code derived from the library, whereas the latter must\nbe combined with the library in order to run.\n\f\n\t\t GNU LESSER GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License Agreement applies to any software library or other\nprogram which contains a notice placed by the copyright holder or\nother authorized party saying it may be distributed under the terms of\nthis Lesser General Public License (also called \"this License\").\nEach licensee is addressed as \"you\".\n\n A \"library\" means a collection of software functions and/or data\nprepared so as to be conveniently linked with application programs\n(which use some of those functions and data) to form executables.\n\n The \"Library\", below, refers to any such software library or work\nwhich has been distributed under these terms. A \"work based on the\nLibrary\" means either the Library or any derivative work under\ncopyright law: that is to say, a work containing the Library or a\nportion of it, either verbatim or with modifications and/or translated\nstraightforwardly into another language. (Hereinafter, translation is\nincluded without limitation in the term \"modification\".)\n\n \"Source code\" for a work means the preferred form of the work for\nmaking modifications to it. For a library, complete source code means\nall the source code for all modules it contains, plus any associated\ninterface definition files, plus the scripts used to control compilation\nand installation of the library.\n\n Activities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning a program using the Library is not restricted, and output from\nsuch a program is covered only if its contents constitute a work based\non the Library (independent of the use of the Library in a tool for\nwriting it). Whether that is true depends on what the Library does\nand what the program that uses the Library does.\n\n 1. You may copy and distribute verbatim copies of the Library's\ncomplete source code as you receive it, in any medium, provided that\nyou conspicuously and appropriately publish on each copy an\nappropriate copyright notice and disclaimer of warranty; keep intact\nall the notices that refer to this License and to the absence of any\nwarranty; and distribute a copy of this License along with the\nLibrary.\n\n You may charge a fee for the physical act of transferring a copy,\nand you may at your option offer warranty protection in exchange for a\nfee.\n\f\n 2. You may modify your copy or copies of the Library or any portion\nof it, thus forming a work based on the Library, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) The modified work must itself be a software library.\n\n b) You must cause the files modified to carry prominent notices\n stating that you changed the files and the date of any change.\n\n c) You must cause the whole of the work to be licensed at no\n charge to all third parties under the terms of this License.\n\n d) If a facility in the modified Library refers to a function or a\n table of data to be supplied by an application program that uses\n the facility, other than as an argument passed when the facility\n is invoked, then you must make a good faith effort to ensure that,\n in the event an application does not supply such function or\n table, the facility still operates, and performs whatever part of\n its purpose remains meaningful.\n\n (For example, a function in a library to compute square roots has\n a purpose that is entirely well-defined independent of the\n application. Therefore, Subsection 2d requires that any\n application-supplied function or table used by this function must\n be optional: if the application does not supply it, the square\n root function must still compute square roots.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Library,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Library, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote\nit.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Library.\n\nIn addition, mere aggregation of another work not based on the Library\nwith the Library (or with a work based on the Library) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may opt to apply the terms of the ordinary GNU General Public\nLicense instead of this License to a given copy of the Library. To do\nthis, you must alter all the notices that refer to this License, so\nthat they refer to the ordinary GNU General Public License, version 2,\ninstead of to this License. (If a newer version than version 2 of the\nordinary GNU General Public License has appeared, then you can specify\nthat version instead if you wish.) Do not make any other change in\nthese notices.\n\f\n Once this change is made in a given copy, it is irreversible for\nthat copy, so the ordinary GNU General Public License applies to all\nsubsequent copies and derivative works made from that copy.\n\n This option is useful when you wish to copy part of the code of\nthe Library into a program that is not a library.\n\n 4. You may copy and distribute the Library (or a portion or\nderivative of it, under Section 2) in object code or executable form\nunder the terms of Sections 1 and 2 above provided that you accompany\nit with the complete corresponding machine-readable source code, which\nmust be distributed under the terms of Sections 1 and 2 above on a\nmedium customarily used for software interchange.\n\n If distribution of object code is made by offering access to copy\nfrom a designated place, then offering equivalent access to copy the\nsource code from the same place satisfies the requirement to\ndistribute the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 5. A program that contains no derivative of any portion of the\nLibrary, but is designed to work with the Library by being compiled or\nlinked with it, is called a \"work that uses the Library\". Such a\nwork, in isolation, is not a derivative work of the Library, and\ntherefore falls outside the scope of this License.\n\n However, linking a \"work that uses the Library\" with the Library\ncreates an executable that is a derivative of the Library (because it\ncontains portions of the Library), rather than a \"work that uses the\nlibrary\". The executable is therefore covered by this License.\nSection 6 states terms for distribution of such executables.\n\n When a \"work that uses the Library\" uses material from a header file\nthat is part of the Library, the object code for the work may be a\nderivative work of the Library even though the source code is not.\nWhether this is true is especially significant if the work can be\nlinked without the Library, or if the work is itself a library. The\nthreshold for this to be true is not precisely defined by law.\n\n If such an object file uses only numerical parameters, data\nstructure layouts and accessors, and small macros and small inline\nfunctions (ten lines or less in length), then the use of the object\nfile is unrestricted, regardless of whether it is legally a derivative\nwork. (Executables containing this object code plus portions of the\nLibrary will still fall under Section 6.)\n\n Otherwise, if the work is a derivative of the Library, you may\ndistribute the object code for the work under the terms of Section 6.\nAny executables containing that work also fall under Section 6,\nwhether or not they are linked directly with the Library itself.\n\f\n 6. As an exception to the Sections above, you may also combine or\nlink a \"work that uses the Library\" with the Library to produce a\nwork containing portions of the Library, and distribute that work\nunder terms of your choice, provided that the terms permit\nmodification of the work for the customer's own use and reverse\nengineering for debugging such modifications.\n\n You must give prominent notice with each copy of the work that the\nLibrary is used in it and that the Library and its use are covered by\nthis License. You must supply a copy of this License. If the work\nduring execution displays copyright notices, you must include the\ncopyright notice for the Library among them, as well as a reference\ndirecting the user to the copy of this License. Also, you must do one\nof these things:\n\n a) Accompany the work with the complete corresponding\n machine-readable source code for the Library including whatever\n changes were used in the work (which must be distributed under\n Sections 1 and 2 above); and, if the work is an executable linked\n with the Library, with the complete machine-readable \"work that\n uses the Library\", as object code and/or source code, so that the\n user can modify the Library and then relink to produce a modified\n executable containing the modified Library. (It is understood\n that the user who changes the contents of definitions files in the\n Library will not necessarily be able to recompile the application\n to use the modified definitions.)\n\n b) Use a suitable shared library mechanism for linking with the\n Library. A suitable mechanism is one that (1) uses at run time a\n copy of the library already present on the user's computer system,\n rather than copying library functions into the executable, and (2)\n will operate properly with a modified version of the library, if\n the user installs one, as long as the modified version is\n interface-compatible with the version that the work was made with.\n\n c) Accompany the work with a written offer, valid for at\n least three years, to give the same user the materials\n specified in Subsection 6a, above, for a charge no more\n than the cost of performing this distribution.\n\n d) If distribution of the work is made by offering access to copy\n from a designated place, offer equivalent access to copy the above\n specified materials from the same place.\n\n e) Verify that the user has already received a copy of these\n materials or that you have already sent this user a copy.\n\n For an executable, the required form of the \"work that uses the\nLibrary\" must include any data and utility programs needed for\nreproducing the executable from it. However, as a special exception,\nthe materials to be distributed need not include anything that is\nnormally distributed (in either source or binary form) with the major\ncomponents (compiler, kernel, and so on) of the operating system on\nwhich the executable runs, unless that component itself accompanies\nthe executable.\n\n It may happen that this requirement contradicts the license\nrestrictions of other proprietary libraries that do not normally\naccompany the operating system. Such a contradiction means you cannot\nuse both them and the Library together in an executable that you\ndistribute.\n\f\n 7. You may place library facilities that are a work based on the\nLibrary side-by-side in a single library together with other library\nfacilities not covered by this License, and distribute such a combined\nlibrary, provided that the separate distribution of the work based on\nthe Library and of the other library facilities is otherwise\npermitted, and provided that you do these two things:\n\n a) Accompany the combined library with a copy of the same work\n based on the Library, uncombined with any other library\n facilities. This must be distributed under the terms of the\n Sections above.\n\n b) Give prominent notice with the combined library of the fact\n that part of it is a work based on the Library, and explaining\n where to find the accompanying uncombined form of the same work.\n\n 8. You may not copy, modify, sublicense, link with, or distribute\nthe Library except as expressly provided under this License. Any\nattempt otherwise to copy, modify, sublicense, link with, or\ndistribute the Library is void, and will automatically terminate your\nrights under this License. However, parties who have received copies,\nor rights, from you under this License will not have their licenses\nterminated so long as such parties remain in full compliance.\n\n 9. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Library or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Library (or any work based on the\nLibrary), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Library or works based on it.\n\n 10. Each time you redistribute the Library (or any work based on the\nLibrary), the recipient automatically receives a license from the\noriginal licensor to copy, distribute, link with or modify the Library\nsubject to these terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties with\nthis License.\n\f\n 11. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Library at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Library by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Library.\n\nIf any portion of this section is held invalid or unenforceable under any\nparticular circumstance, the balance of the section is intended to apply,\nand the section as a whole is intended to apply in other circumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 12. If the distribution and/or use of the Library is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Library under this License may add\nan explicit geographical distribution limitation excluding those countries,\nso that distribution is permitted only in or among countries not thus\nexcluded. In such case, this License incorporates the limitation as if\nwritten in the body of this License.\n\n 13. The Free Software Foundation may publish revised and/or new\nversions of the Lesser General Public License from time to time.\nSuch new versions will be similar in spirit to the present version,\nbut may differ in detail to address new problems or concerns.\n\nEach version is given a distinguishing version number. If the Library\nspecifies a version number of this License which applies to it and\n\"any later version\", you have the option of following the terms and\nconditions either of that version or of any later version published by\nthe Free Software Foundation. If the Library does not specify a\nlicense version number, you may choose any version ever published by\nthe Free Software Foundation.\n\f\n 14. If you wish to incorporate parts of the Library into other free\nprograms whose distribution conditions are incompatible with these,\nwrite to the author to ask for permission. For software which is\ncopyrighted by the Free Software Foundation, write to the Free\nSoftware Foundation; we sometimes make exceptions for this. Our\ndecision will be guided by the two goals of preserving the free status\nof all derivatives of our free software and of promoting the sharing\nand reuse of software generally.\n\n\t\t\t NO WARRANTY\n\n 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO\nWARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.\nEXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR\nOTHER PARTIES PROVIDE THE LIBRARY \"AS IS\" WITHOUT WARRANTY OF ANY\nKIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\nPURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE\nLIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME\nTHE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\n\n 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN\nWRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY\nAND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU\nFOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR\nCONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE\nLIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING\nRENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A\nFAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF\nSUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH\nDAMAGES.\n\n================================================================================\n\nrules_pkg 0.6.0 (Provided under following license)\n================================================================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n================================================================================\n\ndlpack 0.8 (Provided under following license)\n================================================================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"{}\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright 2017 by Contributors\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n===============================================================================\n\nmagic_enum 0.9.3 (Provided under following license)\n===============================================================================\nMIT License\n\nCopyright (c) 2019 - 2023 Daniil Goncharov\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n================================================================================\n\npython-on-whales 0.65.0 (Provided under following license)\n================================================================================\nMIT License\n\nCopyright (c) 2020 Gabriel de Marmiesse de Lussan\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n===============================================================================\n\ncpprestsdk 2.10.18 (Provided under following license)\n===============================================================================\nC++ REST SDK\n\nThe MIT License (MIT)\n\nCopyright (c) Microsoft Corporation\n\nAll rights reserved.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\nthe Software, and to permit persons to whom the Software is furnished to do so,\nsubject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n===============================================================================\n\ngrpc 1.48.0 (Provided under following license)\n===============================================================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n-----------------------------------------------------------\n\nBSD 3-Clause License\n\nCopyright 2016, Google Inc.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice,\nthis list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice,\nthis list of conditions and the following disclaimer in the documentation\nand/or other materials provided with the distribution.\n\n3. Neither the name of the copyright holder nor the names of its\ncontributors may be used to endorse or promote products derived from this\nsoftware without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\nARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\nLIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\nCONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\nSUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\nINTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\nCONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\nARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\nTHE POSSIBILITY OF SUCH DAMAGE.\n\n-----------------------------------------------------------\n\nMozilla Public License Version 2.0\n==================================\n\n1. Definitions\n--------------\n\n1.1. \"Contributor\"\n means each individual or legal entity that creates, contributes to\n the creation of, or owns Covered Software.\n\n1.2. \"Contributor Version\"\n means the combination of the Contributions of others (if any) used\n by a Contributor and that particular Contributor's Contribution.\n\n1.3. \"Contribution\"\n means Covered Software of a particular Contributor.\n\n1.4. \"Covered Software\"\n means Source Code Form to which the initial Contributor has attached\n the notice in Exhibit A, the Executable Form of such Source Code\n Form, and Modifications of such Source Code Form, in each case\n including portions thereof.\n\n1.5. \"Incompatible With Secondary Licenses\"\n means\n\n (a) that the initial Contributor has attached the notice described\n in Exhibit B to the Covered Software; or\n\n (b) that the Covered Software was made available under the terms of\n version 1.1 or earlier of the License, but not also under the\n terms of a Secondary License.\n\n1.6. \"Executable Form\"\n means any form of the work other than Source Code Form.\n\n1.7. \"Larger Work\"\n means a work that combines Covered Software with other material, in\n a separate file or files, that is not Covered Software.\n\n1.8. \"License\"\n means this document.\n\n1.9. \"Licensable\"\n means having the right to grant, to the maximum extent possible,\n whether at the time of the initial grant or subsequently, any and\n all of the rights conveyed by this License.\n\n1.10. \"Modifications\"\n means any of the following:\n\n (a) any file in Source Code Form that results from an addition to,\n deletion from, or modification of the contents of Covered\n Software; or\n\n (b) any new file in Source Code Form that contains any Covered\n Software.\n\n1.11. \"Patent Claims\" of a Contributor\n means any patent claim(s), including without limitation, method,\n process, and apparatus claims, in any patent Licensable by such\n Contributor that would be infringed, but for the grant of the\n License, by the making, using, selling, offering for sale, having\n made, import, or transfer of either its Contributions or its\n Contributor Version.\n\n1.12. \"Secondary License\"\n means either the GNU General Public License, Version 2.0, the GNU\n Lesser General Public License, Version 2.1, the GNU Affero General\n Public License, Version 3.0, or any later versions of those\n licenses.\n\n1.13. \"Source Code Form\"\n means the form of the work preferred for making modifications.\n\n1.14. \"You\" (or \"Your\")\n means an individual or a legal entity exercising rights under this\n License. For legal entities, \"You\" includes any entity that\n controls, is controlled by, or is under common control with You. For\n purposes of this definition, \"control\" means (a) the power, direct\n or indirect, to cause the direction or management of such entity,\n whether by contract or otherwise, or (b) ownership of more than\n fifty percent (50%) of the outstanding shares or beneficial\n ownership of such entity.\n\n2. License Grants and Conditions\n--------------------------------\n\n2.1. Grants\n\nEach Contributor hereby grants You a world-wide, royalty-free,\nnon-exclusive license:\n\n(a) under intellectual property rights (other than patent or trademark)\n Licensable by such Contributor to use, reproduce, make available,\n modify, display, perform, distribute, and otherwise exploit its\n Contributions, either on an unmodified basis, with Modifications, or\n as part of a Larger Work; and\n\n(b) under Patent Claims of such Contributor to make, use, sell, offer\n for sale, have made, import, and otherwise transfer either its\n Contributions or its Contributor Version.\n\n2.2. Effective Date\n\nThe licenses granted in Section 2.1 with respect to any Contribution\nbecome effective for each Contribution on the date the Contributor first\ndistributes such Contribution.\n\n2.3. Limitations on Grant Scope\n\nThe licenses granted in this Section 2 are the only rights granted under\nthis License. No additional rights or licenses will be implied from the\ndistribution or licensing of Covered Software under this License.\nNotwithstanding Section 2.1(b) above, no patent license is granted by a\nContributor:\n\n(a) for any code that a Contributor has removed from Covered Software;\n or\n\n(b) for infringements caused by: (i) Your and any other third party's\n modifications of Covered Software, or (ii) the combination of its\n Contributions with other software (except as part of its Contributor\n Version); or\n\n(c) under Patent Claims infringed by Covered Software in the absence of\n its Contributions.\n\nThis License does not grant any rights in the trademarks, service marks,\nor logos of any Contributor (except as may be necessary to comply with\nthe notice requirements in Section 3.4).\n\n2.4. Subsequent Licenses\n\nNo Contributor makes additional grants as a result of Your choice to\ndistribute the Covered Software under a subsequent version of this\nLicense (see Section 10.2) or under the terms of a Secondary License (if\npermitted under the terms of Section 3.3).\n\n2.5. Representation\n\nEach Contributor represents that the Contributor believes its\nContributions are its original creation(s) or it has sufficient rights\nto grant the rights to its Contributions conveyed by this License.\n\n2.6. Fair Use\n\nThis License is not intended to limit any rights You have under\napplicable copyright doctrines of fair use, fair dealing, or other\nequivalents.\n\n2.7. Conditions\n\nSections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted\nin Section 2.1.\n\n3. Responsibilities\n-------------------\n\n3.1. Distribution of Source Form\n\nAll distribution of Covered Software in Source Code Form, including any\nModifications that You create or to which You contribute, must be under\nthe terms of this License. You must inform recipients that the Source\nCode Form of the Covered Software is governed by the terms of this\nLicense, and how they can obtain a copy of this License. You may not\nattempt to alter or restrict the recipients' rights in the Source Code\nForm.\n\n3.2. Distribution of Executable Form\n\nIf You distribute Covered Software in Executable Form then:\n\n(a) such Covered Software must also be made available in Source Code\n Form, as described in Section 3.1, and You must inform recipients of\n the Executable Form how they can obtain a copy of such Source Code\n Form by reasonable means in a timely manner, at a charge no more\n than the cost of distribution to the recipient; and\n\n(b) You may distribute such Executable Form under the terms of this\n License, or sublicense it under different terms, provided that the\n license for the Executable Form does not attempt to limit or alter\n the recipients' rights in the Source Code Form under this License.\n\n3.3. Distribution of a Larger Work\n\nYou may create and distribute a Larger Work under terms of Your choice,\nprovided that You also comply with the requirements of this License for\nthe Covered Software. If the Larger Work is a combination of Covered\nSoftware with a work governed by one or more Secondary Licenses, and the\nCovered Software is not Incompatible With Secondary Licenses, this\nLicense permits You to additionally distribute such Covered Software\nunder the terms of such Secondary License(s), so that the recipient of\nthe Larger Work may, at their option, further distribute the Covered\nSoftware under the terms of either this License or such Secondary\nLicense(s).\n\n3.4. Notices\n\nYou may not remove or alter the substance of any license notices\n(including copyright notices, patent notices, disclaimers of warranty,\nor limitations of liability) contained within the Source Code Form of\nthe Covered Software, except that You may alter any license notices to\nthe extent required to remedy known factual inaccuracies.\n\n3.5. Application of Additional Terms\n\nYou may choose to offer, and to charge a fee for, warranty, support,\nindemnity or liability obligations to one or more recipients of Covered\nSoftware. However, You may do so only on Your own behalf, and not on\nbehalf of any Contributor. You must make it absolutely clear that any\nsuch warranty, support, indemnity, or liability obligation is offered by\nYou alone, and You hereby agree to indemnify every Contributor for any\nliability incurred by such Contributor as a result of warranty, support,\nindemnity or liability terms You offer. You may include additional\ndisclaimers of warranty and limitations of liability specific to any\njurisdiction.\n\n4. Inability to Comply Due to Statute or Regulation\n---------------------------------------------------\n\nIf it is impossible for You to comply with any of the terms of this\nLicense with respect to some or all of the Covered Software due to\nstatute, judicial order, or regulation then You must: (a) comply with\nthe terms of this License to the maximum extent possible; and (b)\ndescribe the limitations and the code they affect. Such description must\nbe placed in a text file included with all distributions of the Covered\nSoftware under this License. Except to the extent prohibited by statute\nor regulation, such description must be sufficiently detailed for a\nrecipient of ordinary skill to be able to understand it.\n\n5. Termination\n--------------\n\n5.1. The rights granted under this License will terminate automatically\nif You fail to comply with any of its terms. However, if You become\ncompliant, then the rights granted under this License from a particular\nContributor are reinstated (a) provisionally, unless and until such\nContributor explicitly and finally terminates Your grants, and (b) on an\nongoing basis, if such Contributor fails to notify You of the\nnon-compliance by some reasonable means prior to 60 days after You have\ncome back into compliance. Moreover, Your grants from a particular\nContributor are reinstated on an ongoing basis if such Contributor\nnotifies You of the non-compliance by some reasonable means, this is the\nfirst time You have received notice of non-compliance with this License\nfrom such Contributor, and You become compliant prior to 30 days after\nYour receipt of the notice.\n\n5.2. If You initiate litigation against any entity by asserting a patent\ninfringement claim (excluding declaratory judgment actions,\ncounter-claims, and cross-claims) alleging that a Contributor Version\ndirectly or indirectly infringes any patent, then the rights granted to\nYou by any and all Contributors for the Covered Software under Section\n2.1 of this License shall terminate.\n\n5.3. In the event of termination under Sections 5.1 or 5.2 above, all\nend user license agreements (excluding distributors and resellers) which\nhave been validly granted by You or Your distributors under this License\nprior to termination shall survive termination.\n\n************************************************************************\n* *\n* 6. Disclaimer of Warranty *\n* ------------------------- *\n* *\n* Covered Software is provided under this License on an \"as is\" *\n* basis, without warranty of any kind, either expressed, implied, or *\n* statutory, including, without limitation, warranties that the *\n* Covered Software is free of defects, merchantable, fit for a *\n* particular purpose or non-infringing. The entire risk as to the *\n* quality and performance of the Covered Software is with You. *\n* Should any Covered Software prove defective in any respect, You *\n* (not any Contributor) assume the cost of any necessary servicing, *\n* repair, or correction. This disclaimer of warranty constitutes an *\n* essential part of this License. No use of any Covered Software is *\n* authorized under this License except under this disclaimer. *\n* *\n************************************************************************\n\n************************************************************************\n* *\n* 7. Limitation of Liability *\n* -------------------------- *\n* *\n* Under no circumstances and under no legal theory, whether tort *\n* (including negligence), contract, or otherwise, shall any *\n* Contributor, or anyone who distributes Covered Software as *\n* permitted above, be liable to You for any direct, indirect, *\n* special, incidental, or consequential damages of any character *\n* including, without limitation, damages for lost profits, loss of *\n* goodwill, work stoppage, computer failure or malfunction, or any *\n* and all other commercial damages or losses, even if such party *\n* shall have been informed of the possibility of such damages. This *\n* limitation of liability shall not apply to liability for death or *\n* personal injury resulting from such party's negligence to the *\n* extent applicable law prohibits such limitation. Some *\n* jurisdictions do not allow the exclusion or limitation of *\n* incidental or consequential damages, so this exclusion and *\n* limitation may not apply to You. *\n* *\n************************************************************************\n\n8. Litigation\n-------------\n\nAny litigation relating to this License may be brought only in the\ncourts of a jurisdiction where the defendant maintains its principal\nplace of business and such litigation shall be governed by laws of that\njurisdiction, without reference to its conflict-of-law provisions.\nNothing in this Section shall prevent a party's ability to bring\ncross-claims or counter-claims.\n\n9. Miscellaneous\n----------------\n\nThis License represents the complete agreement concerning the subject\nmatter hereof. If any provision of this License is held to be\nunenforceable, such provision shall be reformed only to the extent\nnecessary to make it enforceable. Any law or regulation which provides\nthat the language of a contract shall be construed against the drafter\nshall not be used to construe this License against a Contributor.\n\n10. Versions of the License\n---------------------------\n\n10.1. New Versions\n\nMozilla Foundation is the license steward. Except as provided in Section\n10.3, no one other than the license steward has the right to modify or\npublish new versions of this License. Each version will be given a\ndistinguishing version number.\n\n10.2. Effect of New Versions\n\nYou may distribute the Covered Software under the terms of the version\nof the License under which You originally received the Covered Software,\nor under the terms of any subsequent version published by the license\nsteward.\n\n10.3. Modified Versions\n\nIf you create software not governed by this License, and you want to\ncreate a new license for such software, you may create and use a\nmodified version of this License if you rename the license and remove\nany references to the name of the license steward (except to note that\nsuch modified license differs from this License).\n\n10.4. Distributing Source Code Form that is Incompatible With Secondary\nLicenses\n\nIf You choose to distribute Source Code Form that is Incompatible With\nSecondary Licenses under the terms of this version of the License, the\nnotice described in Exhibit B of this License must be attached.\n\nExhibit A - Source Code Form License Notice\n-------------------------------------------\n\n This Source Code Form is subject to the terms of the Mozilla Public\n License, v. 2.0. If a copy of the MPL was not distributed with this\n file, You can obtain one at http://mozilla.org/MPL/2.0/.\n\nIf it is not possible or desirable to put the notice in a particular\nfile, then You may include the notice in a location (such as a LICENSE\nfile in a relevant directory) where a recipient would be likely to look\nfor such a notice.\n\nYou may add additional accurate notices of copyright ownership.\n\nExhibit B - \"Incompatible With Secondary Licenses\" Notice\n---------------------------------------------------------\n\n This Source Code Form is \"Incompatible With Secondary Licenses\", as\n defined by the Mozilla Public License, v. 2.0.\n===============================================================================\n\nboringssl-b9232f9e27e5668bc0414879dcdedb2a59ea75f2 (Provided under following license)\n===============================================================================\nBoringSSL is a fork of OpenSSL. As such, large parts of it fall under OpenSSL\nlicensing. Files that are completely new have a Google copyright and an ISC\nlicense. This license is reproduced at the bottom of this file.\n\nContributors to BoringSSL are required to follow the CLA rules for Chromium:\nhttps://cla.developers.google.com/clas\n\nFiles in third_party/ have their own licenses, as described therein. The MIT\nlicense, for third_party/fiat, which, unlike other third_party directories, is\ncompiled into non-test libraries, is included below.\n\nThe OpenSSL toolkit stays under a dual license, i.e. both the conditions of the\nOpenSSL License and the original SSLeay license apply to the toolkit. See below\nfor the actual license texts. Actually both licenses are BSD-style Open Source\nlicenses. In case of any license issues related to OpenSSL please contact\nopenssl-core@openssl.org.\n\nThe following are Google-internal bug numbers where explicit permission from\nsome authors is recorded for use of their work. (This is purely for our own\nrecord keeping.)\n 27287199\n 27287880\n 27287883\n\n OpenSSL License\n ---------------\n\n/* ====================================================================\n * Copyright (c) 1998-2011 The OpenSSL Project. All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n *\n * 1. Redistributions of source code must retain the above copyright\n * notice, this list of conditions and the following disclaimer.\n *\n * 2. Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in\n * the documentation and/or other materials provided with the\n * distribution.\n *\n * 3. All advertising materials mentioning features or use of this\n * software must display the following acknowledgment:\n * \"This product includes software developed by the OpenSSL Project\n * for use in the OpenSSL Toolkit. (http://www.openssl.org/)\";\n *\n * 4. The names \"OpenSSL Toolkit\" and \"OpenSSL Project\" must not be used to\n * endorse or promote products derived from this software without\n * prior written permission. For written permission, please contact\n * openssl-core@openssl.org.\n *\n * 5. Products derived from this software may not be called \"OpenSSL\"\n * nor may \"OpenSSL\" appear in their names without prior written\n * permission of the OpenSSL Project.\n *\n * 6. Redistributions of any form whatsoever must retain the following\n * acknowledgment:\n * \"This product includes software developed by the OpenSSL Project\n * for use in the OpenSSL Toolkit (http://www.openssl.org/)\";\n *\n * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY\n * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR\n * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT\n * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED\n * OF THE POSSIBILITY OF SUCH DAMAGE.\n * ====================================================================\n *\n * This product includes cryptographic software written by Eric Young\n * (eay@cryptsoft.com). This product includes software written by Tim\n * Hudson (tjh@cryptsoft.com).\n *\n */\n\n Original SSLeay License\n -----------------------\n\n/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)\n * All rights reserved.\n *\n * This package is an SSL implementation written\n * by Eric Young (eay@cryptsoft.com).\n * The implementation was written so as to conform with Netscapes SSL.\n *\n * This library is free for commercial and non-commercial use as long as\n * the following conditions are aheared to. The following conditions\n * apply to all code found in this distribution, be it the RC4, RSA,\n * lhash, DES, etc., code; not just the SSL code. The SSL documentation\n * included with this distribution is covered by the same copyright terms\n * except that the holder is Tim Hudson (tjh@cryptsoft.com).\n *\n * Copyright remains Eric Young's, and as such any Copyright notices in\n * the code are not to be removed.\n * If this package is used in a product, Eric Young should be given attribution\n * as the author of the parts of the library used.\n * This can be in the form of a textual message at program startup or\n * in documentation (online or textual) provided with the package.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n * 1. Redistributions of source code must retain the copyright\n * notice, this list of conditions and the following disclaimer.\n * 2. Redistributions in binary form must reproduce the above copyright\n * notice, this list of conditions and the following disclaimer in the\n * documentation and/or other materials provided with the distribution.\n * 3. All advertising materials mentioning features or use of this software\n * must display the following acknowledgement:\n * \"This product includes cryptographic software written by\n * Eric Young (eay@cryptsoft.com)\"\n * The word 'cryptographic' can be left out if the rouines from the library\n * being used are not cryptographic related :-).\n * 4. If you include any Windows specific code (or a derivative thereof) from\n * the apps directory (application code) you must include an acknowledgement:\n * \"This product includes software written by Tim Hudson (tjh@cryptsoft.com)\"\n *\n * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n * SUCH DAMAGE.\n *\n * The licence and distribution terms for any publically available version or\n * derivative of this code cannot be changed. i.e. this code cannot simply be\n * copied and put under another distribution licence\n * [including the GNU Public Licence.]\n */\n\n\nISC license used for completely new code in BoringSSL:\n\n/* Copyright (c) 2015, Google Inc.\n *\n * Permission to use, copy, modify, and/or distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY\n * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION\n * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN\n * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */\n\n\nThe code in third_party/fiat carries the MIT license:\n\nCopyright (c) 2015-2016 the fiat-crypto authors (see\nhttps://github.com/mit-plv/fiat-crypto/blob/master/AUTHORS).\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\n\nLicenses for support code\n-------------------------\n\nParts of the TLS test suite are under the Go license. This code is not included\nin BoringSSL (i.e. libcrypto and libssl) when compiled, however, so\ndistributing code linked against BoringSSL does not trigger this license:\n\nCopyright (c) 2009 The Go Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n\nBoringSSL uses the Chromium test infrastructure to run a continuous build,\ntrybots etc. The scripts which manage this, and the script for generating build\nmetadata, are under the Chromium license. Distributing code linked against\nBoringSSL does not trigger this license.\n\nCopyright 2015 The Chromium Authors. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n===============================================================================\n\nboost 1.79.0 (Provided under following license)\n===============================================================================\nBoost Software License - Version 1.0 - August 17th, 2003\n\nPermission is hereby granted, free of charge, to any person or organization\nobtaining a copy of the software and accompanying documentation covered by\nthis license (the \"Software\") to use, reproduce, display, distribute,\nexecute, and transmit the Software, and to prepare derivative works of the\nSoftware, and to permit third-parties to whom the Software is furnished to\ndo so, all subject to the following:\n\nThe copyright notices in the Software and this entire statement, including\nthe above license grant, this restriction and the following disclaimer,\nmust be included in all copies of the Software, in whole or in part, and\nall derivative works of the Software, unless such copies or derivative\nworks are solely in the form of machine-executable object code generated by\na source language processor.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT\nSHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE\nFOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,\nARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\nDEALINGS IN THE SOFTWARE.\n===============================================================================\n\nprotobuf-22d0e265de7d2b3d2e9a00d071313502e7d4cccf (Provided under following license)\n===============================================================================\nCopyright 2008 Google Inc. All rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are\nmet:\n\n * Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n * Redistributions in binary form must reproduce the above\ncopyright notice, this list of conditions and the following disclaimer\nin the documentation and/or other materials provided with the\ndistribution.\n * Neither the name of Google Inc. nor the names of its\ncontributors may be used to endorse or promote products derived from\nthis software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,\nDATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY\nTHEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\nCode generated by the Protocol Buffer compiler is owned by the owner\nof the input file used when generating it. This code is not\nstandalone and requires a support library to be linked with it. This\nsupport library is itself covered by the above license.\n===============================================================================\n\npyarmor 7.7.4 (Provided under following license)\n===============================================================================\nPyarmor 8.0 End User License Agreement\n\nThe following agreement regarding Pyarmor is made between Jondy Zhao -\nreferred to as \"licensor\" - and anyone or organization who is installing,\naccessing or in any other way using Pyarmor - referred to as \"user\" or\n\"you\".\n\n1. Definitions\n--------------\n\n1.1. \"This Software\"\n\n means Pyarmor 8.0, it doesn't include Pyarmor prior to 8.0. Pyarmor 8.0 is\n rewritten, and provides new features. For compatibility, Pyarmor 8.0 also\n includes most of the old features, this license doesn't apply to those old\n features. It's only for new features.\n\n1.2. \"Product\"\n means any application or software for sale.\n\n1.3. \"One Product\"\n means a product name and everything that makes up this name. It includes\n all the devices to develop, build, debug, test product. It also includes\n product current version, history versions and all the future versions.\n\n One product may has several variants, each variant name is composed of\n product name plus feature name. As long as the proportion of the\n variable part is far less than that of the common part, they're\n considered as \"one product\".\n\n1.4. \"Customer\"\n means anyone who uses user's product.\n\n1.5 \"Script\"\n means Python script.\n\n1.6 \"User Script\"\n means user owns this script.\n\n1.7 \"Other Script\"\n means user doesn't own this script.\n\n1.8 \"Mix Str\"\n means a feature of this software to obfuscate string constant in script\n\n1.9 \"BCC Mode\"\n means an irreversible obfuscation method, a feature of this software\n\n1.10 \"RFT Mode\"\n means an irreversible obfuscation method, a feature of this software\n\n1.11 \"Big Script\"\n means script size exceeds a certain value\n\n1.12 \"Pyarmor License\"\n means a file issued by licensor to unlock this software limitations\n\n1.13 \"Basic License\"\n means a kind of Pyarmor License\n\n1.13 \"Pro License\"\n means a kind of Pyarmor License\n\n1.14 \"Group License\"\n means a kind of Pyarmor License\n\n1.15 \"License No.\"\n means a string with format \"pyarmor-vax-xxxxxx\", \"x\" stands for a\n digital, each Pyarmor License has an unique License No.\n\n1.16 \"Licensed Product\"\n means product has been registered to one Pyarmor License.\n\n2. License Grants and Conditions\n--------------------------------\n\nInstalling and using this software signifies acceptance of these terms and\nconditions of the license. If you do not agree with the terms of this\nlicense, you must remove all of this software files from your storage\ndevices and cease to use this software.\n\n2.1. Trial Version Limitations\n\nThis software is published as shareware, free trial version never expires,\nbut there are some limitations.\n\n2.1.1 Can not obfuscate big script\n2.1.2 Can not use feature Mix Str\n2.1.3 Can not use feature RFT Mode, BCC Mode\n2.1.4 Can not be used in any commercial product if the total sale income of\n this product is larger than 30x license fees\n2.1.5 Can not be used to provide obfuscation service in any form\n\n2.2. Grants\n\nUser purchases Pyarmor License to unlock these limitations except 2.1.5.\n\nLicensor issues 3 kind of Pyarmor License.\n\n2.2.1 Pyarmor Basic, unlock limitations 2.1.1, 2.1.2, 2.1.4\n2.2.2 Pyarmor Pro, unlock limitations 2.1.1, 2.1.2, 2.1.3, 2.1.4\n2.2.3 Pyarmor Group, unlock limitations 2.1.1, 2.1.2, 2.1.3, 2.1.4\n\nPyarmor Basic and Pyarmor Pro need internet connection to verify, it doesn't\nwork in the device without internet connection.\n\nPyarmor Group need not internet connection.\n\nEach Pyarmor License only need pay once, not periodically.\n\n2.3 Conditions\n\n2.3.1 Each Pyarmor License can only be used to register One Product. Each\n Licensed Product has an unique License No. in global. If user has many\n products, each product need purchase one Pyarmor License. Except 2.6.1\n\n2.3.2 Pyarmor License could be installed in many machines and devices which\n used to develop, build, debug, test and support Licensed Product. But\n there is limitation to be used at the same time. See 2.3.3\n\n2.3.3 Pyarmor Basic and Pro License can only be used in no more than 100\n devices in 24 hours. Pyarmor License be used means use any feature of\n Pyarmor in one machine. Running obfuscated scripts generated by\n Pyarmor is not considered as Pyarmor License be used.\n\n2.3.4 Pyarmor Basic and Pro License need internet connection to verify.\n\n2.3.5 Pyarmor License could not be installed in customer's devices.\n\n2.3.6 Pyarmor License could not be used to obfuscate any other scripts.\n\n2.3.7 Pyarmor License could not be transferred to other product.\n\n2.4 Special Cases\n\n2.4.1 When product name is changed, but the product features are same,\n Pyarmor License could be used without changing registration product\n name.\n\n2.4.2 When organization user is renamed, or acquired by others, only product\n name is not changed, Pyarmor License need change nothing, and still\n could be used. But if product name is changed, even product functions\n are same, Pyarmor License can't be used again.\n\n2.4.3 When product in developing and its name is not defined, the initial\n registration could use \"TBD\" as the product name. In this case,\n product name can be changed once. Before this product is sold, user\n must change registration name to real product name.\n\n2.5 Modifying Software\n\nUser could modify Python scripts of this software to meet needs. But this\nmodified software could only be used in Licensed Product, it could not be\ndistributed to others.\n\n2.6 Fair Use\n\nThis License is not intended to limit any rights users have under applicable\ncopyright doctrines of fair use, fair dealing, or other equivalents.\n\n2.6.1 If user has many products, and has purchased one license for the first\n product. The second product could use first product license only if sale\n income of the second product less than 30x license fees. Once greater than\n 30x license fees, the second product need purchase its own license. It's\n same to user's other products.\n\n3. Responsibilities and Commitments\n-----------------------------------\n\n3.1 This software does nothing except the features described in the software\n documentation.\n\n3.2 Using Pyarmor Basic and Pro License, this software need internet\n connection to request authorization. And only the related files of\n Pyarmor License, serial number of hard disk, Ethernet address, IPv4/IPv6\n address, hostname will be sent to remote server for verification.\n\n3.3 Except 3.2, this software does not record and collect any other device\n information, and need not connect to internet.\n\n3.4 Regarding to obfuscated scripts generated by this software\n\n3.4.1 this software has no any control or limitation to obfuscated scripts,\n the behaviors of obfuscated scripts are totally defined by user.\n\n3.4.2 License No. and product name will be embedded into obfuscated scripts,\n user's regname, email and other information are not.\n\n4. Termination\n--------------\n\nThe rights granted under this License will terminate automatically if You\nfail to comply with any of its terms.\n\n4.1 You issue chargeback after purchased Pyarmor License has been registered\n to one product. Even chargeback is rejected by bank or user cancels\n chargeback, this Pyarmor License can't be used again.\n\n4.2 You let others got Pyarmor License intentionally or unintentionally\n\n4.3 You lost Pyarmor License by hacker\n\n4.4 In any cases include 4.2, 4.3, once licensor find too many machines use\n one Pyarmor License exceeds permission, this Pyarmor License will be\n ceased, and never could be used again.\n\n4.5 In any cases if licensor finds one Pyarmor License is used to other\n product, even it's caused by 4.3, this Pyarmor License will be ceased. A\n notify email will be sent to registration email of this Pyarmor License.\n\n5. Restrictions\n---------------\n\nYou shall not (and shall not allow any third party to):\n\n5.1 decompile, disassemble, or otherwise reverse engineer any binary files\n of this software;\n\n5.2 distribute, sell, sublicense, rent, lease, or use this software (or any\n portion thereof) for time sharing, hosting, service provider, or like\n purposes;\n\n5.3 remove any product identification, proprietary, copyright, or other\n notices contained in this software;\n\n5.4 copy, modify (except as expressly permitted in this Agreement) or\n translate any part of this software, create a derivative work of any\n part of this software, or incorporate this software into or with other\n software, except to the extent expressly authorized in writing by\n licensor;\n\n5.5 attempt to circumvent or disable the security key mechanism that\n protects this software against unauthorized use (except and only to the\n extent that applicable law prohibits or restricts such restrictions);\n\n6. Disclaimer of Warranty\n-------------------------\n\nThis Software is provided under this License on an \"as is\" basis, without\nwarranty of any kind, either expressed, implied, or statutory, including,\nwithout limitation, warranties that this software is free of defects, fit\nfor a particular purpose or non-infringing. The entire risk as to the\nquality and performance of this software is with users. Neither the licensor\nnor the agents of the licensor will be liable for data loss, damages, loss\nof profits or any other kind of loss while using or misusing this\nsoftware. This disclaimer of warranty constitutes an essential part of this\nLicense. No use of this software is authorized under this License except\nunder this disclaimer.\n\n7. Changes to this Agreement\n----------------------------\n\nLicensor reserves the right, at its sole discretion, to modify or replace\nthis Agreement at any time. If a revision is material licensor will provide\nat least 30 days' notice prior to any new terms taking effect. What\nconstitutes a material change will be determined at the sole discretion of\nthe licensor.\n\nBy continuing to access or use this software after any revisions become\neffective, You agree to be bound by the revised terms. If You do not agree\nto the new terms, You are no longer authorized to use this software.\n\n8. Litigation\n-------------\n\nAny litigation relating to this License may be brought only in the courts of\na jurisdiction where the defendant maintains its principal place of business\nand such litigation shall be governed by laws of that jurisdiction, without\nreference to its conflict-of-law provisions. Nothing in this Section shall\nprevent a party's ability to bring cross-claims or counter-claims.\n===============================================================================\n\npyinstaller 5.13.2 (Provided under following license)\n===============================================================================\n================================\n The PyInstaller licensing terms\n================================\n\n\nCopyright (c) 2010-2023, PyInstaller Development Team\nCopyright (c) 2005-2009, Giovanni Bajo\nBased on previous work under copyright (c) 2002 McMillan Enterprises, Inc.\n\n\nPyInstaller is licensed under the terms of the GNU General Public License\nas published by the Free Software Foundation; either version 2 of the License,\nor (at your option) any later version.\n\n\nBootloader Exception\n--------------------\n\nIn addition to the permissions in the GNU General Public License, the\nauthors give you unlimited permission to link or embed compiled bootloader\nand related files into combinations with other programs, and to distribute\nthose combinations without any restriction coming from the use of those\nfiles. (The General Public License restrictions do apply in other respects;\nfor example, they cover modification of the files, and distribution when\nnot linked into a combined executable.)\n\n\nBootloader and Related Files\n----------------------------\n\nBootloader and related files are files which are embedded within the\nfinal executable. This includes files in directories:\n\n./bootloader/\n./PyInstaller/loader\n\n\nRun-time Hooks\n----------------------------\n\nRun-time Hooks are a different kind of files embedded within the final\nexecutable. To ease moving them into a separate repository, or into the\nrespective project, these files are now licensed under the Apache License,\nVersion 2.0.\n\nRun-time Hooks are in the directory\n./PyInstaller/hooks/rthooks\n\n\nThe PyInstaller.isolated submodule\n----------------------------------\n\nBy request, the PyInstaller.isolated submodule and its corresponding tests are\nadditionally licensed with the MIT license so that it may be reused outside of\nPyInstaller under GPL 2.0 or MIT terms and conditions -- whichever is the most\nsuitable to the recipient downstream project. Affected files/directories are:\n\n./PyInstaller/isolated/\n./tests/unit/test_isolation.py\n\n\nAbout the PyInstaller Development Team\n--------------------------------------\n\nThe PyInstaller Development Team is the set of contributors\nto the PyInstaller project. A full list with details is kept\nin the documentation directory, in the file\n``doc/CREDITS.rst``.\n\nThe core team that coordinates development on GitHub can be found here:\nhttps://github.com/pyinstaller/pyinstaller. As of 2021, it consists of:\n\n* Hartmut Goebel\n* Jasper Harrison\n* Bryan Jones\n* Brenainn Woodsend\n* Rok Mandeljc\n\nOur Copyright Policy\n--------------------\n\nPyInstaller uses a shared copyright model. Each contributor maintains copyright\nover their contributions to PyInstaller. But, it is important to note that these\ncontributions are typically only changes to the repositories. Thus,\nthe PyInstaller source code, in its entirety is not the copyright of any single\nperson or institution. Instead, it is the collective copyright of the entire\nPyInstaller Development Team. If individual contributors want to maintain\na record of what changes/contributions they have specific copyright on, they\nshould indicate their copyright in the commit message of the change, when they\ncommit the change to the PyInstaller repository.\n\nWith this in mind, the following banner should be used in any source code file\nto indicate the copyright and license terms:\n\n\n#-----------------------------------------------------------------------------\n# Copyright (c) 2005-2023, PyInstaller Development Team.\n#\n# Distributed under the terms of the GNU General Public License (version 2\n# or later) with exception for distributing the bootloader.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n#\n# SPDX-License-Identifier: (GPL-2.0-or-later WITH Bootloader-exception)\n#-----------------------------------------------------------------------------\n\n\nFor run-time hooks, the following banner should be used:\n\n#-----------------------------------------------------------------------------\n# Copyright (c) 2005-2023, PyInstaller Development Team.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n#\n# The full license is in the file COPYING.txt, distributed with this software.\n#\n# SPDX-License-Identifier: Apache-2.0\n#-----------------------------------------------------------------------------\n\n\n================================\nGNU General Public License\n================================\n\nhttps://gnu.org/licenses/gpl-2.0.html\n\n\n\t\t GNU GENERAL PUBLIC LICENSE\n\t\t Version 2, June 1991\n\n Copyright (C) 1989, 1991 Free Software Foundation, Inc.\n 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA\n Everyone is permitted to copy and distribute verbatim copies\n of this license document, but changing it is not allowed.\n\n\t\t\t Preamble\n\n The licenses for most software are designed to take away your\nfreedom to share and change it. By contrast, the GNU General Public\nLicense is intended to guarantee your freedom to share and change free\nsoftware--to make sure the software is free for all its users. This\nGeneral Public License applies to most of the Free Software\nFoundation's software and to any other program whose authors commit to\nusing it. (Some other Free Software Foundation software is covered by\nthe GNU Library General Public License instead.) You can apply it to\nyour programs, too.\n\n When we speak of free software, we are referring to freedom, not\nprice. Our General Public Licenses are designed to make sure that you\nhave the freedom to distribute copies of free software (and charge for\nthis service if you wish), that you receive source code or can get it\nif you want it, that you can change the software or use pieces of it\nin new free programs; and that you know you can do these things.\n\n To protect your rights, we need to make restrictions that forbid\nanyone to deny you these rights or to ask you to surrender the rights.\nThese restrictions translate to certain responsibilities for you if you\ndistribute copies of the software, or if you modify it.\n\n For example, if you distribute copies of such a program, whether\ngratis or for a fee, you must give the recipients all the rights that\nyou have. You must make sure that they, too, receive or can get the\nsource code. And you must show them these terms so they know their\nrights.\n\n We protect your rights with two steps: (1) copyright the software, and\n(2) offer you this license which gives you legal permission to copy,\ndistribute and/or modify the software.\n\n Also, for each author's protection and ours, we want to make certain\nthat everyone understands that there is no warranty for this free\nsoftware. If the software is modified by someone else and passed on, we\nwant its recipients to know that what they have is not the original, so\nthat any problems introduced by others will not reflect on the original\nauthors' reputations.\n\n Finally, any free program is threatened constantly by software\npatents. We wish to avoid the danger that redistributors of a free\nprogram will individually obtain patent licenses, in effect making the\nprogram proprietary. To prevent this, we have made it clear that any\npatent must be licensed for everyone's free use or not licensed at all.\n\n The precise terms and conditions for copying, distribution and\nmodification follow.\n\n\t\t GNU GENERAL PUBLIC LICENSE\n TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION\n\n 0. This License applies to any program or other work which contains\na notice placed by the copyright holder saying it may be distributed\nunder the terms of this General Public License. The \"Program\", below,\nrefers to any such program or work, and a \"work based on the Program\"\nmeans either the Program or any derivative work under copyright law:\nthat is to say, a work containing the Program or a portion of it,\neither verbatim or with modifications and/or translated into another\nlanguage. (Hereinafter, translation is included without limitation in\nthe term \"modification\".) Each licensee is addressed as \"you\".\n\nActivities other than copying, distribution and modification are not\ncovered by this License; they are outside its scope. The act of\nrunning the Program is not restricted, and the output from the Program\nis covered only if its contents constitute a work based on the\nProgram (independent of having been made by running the Program).\nWhether that is true depends on what the Program does.\n\n 1. You may copy and distribute verbatim copies of the Program's\nsource code as you receive it, in any medium, provided that you\nconspicuously and appropriately publish on each copy an appropriate\ncopyright notice and disclaimer of warranty; keep intact all the\nnotices that refer to this License and to the absence of any warranty;\nand give any other recipients of the Program a copy of this License\nalong with the Program.\n\nYou may charge a fee for the physical act of transferring a copy, and\nyou may at your option offer warranty protection in exchange for a fee.\n\n 2. You may modify your copy or copies of the Program or any portion\nof it, thus forming a work based on the Program, and copy and\ndistribute such modifications or work under the terms of Section 1\nabove, provided that you also meet all of these conditions:\n\n a) You must cause the modified files to carry prominent notices\n stating that you changed the files and the date of any change.\n\n b) You must cause any work that you distribute or publish, that in\n whole or in part contains or is derived from the Program or any\n part thereof, to be licensed as a whole at no charge to all third\n parties under the terms of this License.\n\n c) If the modified program normally reads commands interactively\n when run, you must cause it, when started running for such\n interactive use in the most ordinary way, to print or display an\n announcement including an appropriate copyright notice and a\n notice that there is no warranty (or else, saying that you provide\n a warranty) and that users may redistribute the program under\n these conditions, and telling the user how to view a copy of this\n License. (Exception: if the Program itself is interactive but\n does not normally print such an announcement, your work based on\n the Program is not required to print an announcement.)\n\nThese requirements apply to the modified work as a whole. If\nidentifiable sections of that work are not derived from the Program,\nand can be reasonably considered independent and separate works in\nthemselves, then this License, and its terms, do not apply to those\nsections when you distribute them as separate works. But when you\ndistribute the same sections as part of a whole which is a work based\non the Program, the distribution of the whole must be on the terms of\nthis License, whose permissions for other licensees extend to the\nentire whole, and thus to each and every part regardless of who wrote it.\n\nThus, it is not the intent of this section to claim rights or contest\nyour rights to work written entirely by you; rather, the intent is to\nexercise the right to control the distribution of derivative or\ncollective works based on the Program.\n\nIn addition, mere aggregation of another work not based on the Program\nwith the Program (or with a work based on the Program) on a volume of\na storage or distribution medium does not bring the other work under\nthe scope of this License.\n\n 3. You may copy and distribute the Program (or a work based on it,\nunder Section 2) in object code or executable form under the terms of\nSections 1 and 2 above provided that you also do one of the following:\n\n a) Accompany it with the complete corresponding machine-readable\n source code, which must be distributed under the terms of Sections\n 1 and 2 above on a medium customarily used for software interchange; or,\n\n b) Accompany it with a written offer, valid for at least three\n years, to give any third party, for a charge no more than your\n cost of physically performing source distribution, a complete\n machine-readable copy of the corresponding source code, to be\n distributed under the terms of Sections 1 and 2 above on a medium\n customarily used for software interchange; or,\n\n c) Accompany it with the information you received as to the offer\n to distribute corresponding source code. (This alternative is\n allowed only for noncommercial distribution and only if you\n received the program in object code or executable form with such\n an offer, in accord with Subsection b above.)\n\nThe source code for a work means the preferred form of the work for\nmaking modifications to it. For an executable work, complete source\ncode means all the source code for all modules it contains, plus any\nassociated interface definition files, plus the scripts used to\ncontrol compilation and installation of the executable. However, as a\nspecial exception, the source code distributed need not include\nanything that is normally distributed (in either source or binary\nform) with the major components (compiler, kernel, and so on) of the\noperating system on which the executable runs, unless that component\nitself accompanies the executable.\n\nIf distribution of executable or object code is made by offering\naccess to copy from a designated place, then offering equivalent\naccess to copy the source code from the same place counts as\ndistribution of the source code, even though third parties are not\ncompelled to copy the source along with the object code.\n\n 4. You may not copy, modify, sublicense, or distribute the Program\nexcept as expressly provided under this License. Any attempt\notherwise to copy, modify, sublicense or distribute the Program is\nvoid, and will automatically terminate your rights under this License.\nHowever, parties who have received copies, or rights, from you under\nthis License will not have their licenses terminated so long as such\nparties remain in full compliance.\n\n 5. You are not required to accept this License, since you have not\nsigned it. However, nothing else grants you permission to modify or\ndistribute the Program or its derivative works. These actions are\nprohibited by law if you do not accept this License. Therefore, by\nmodifying or distributing the Program (or any work based on the\nProgram), you indicate your acceptance of this License to do so, and\nall its terms and conditions for copying, distributing or modifying\nthe Program or works based on it.\n\n 6. Each time you redistribute the Program (or any work based on the\nProgram), the recipient automatically receives a license from the\noriginal licensor to copy, distribute or modify the Program subject to\nthese terms and conditions. You may not impose any further\nrestrictions on the recipients' exercise of the rights granted herein.\nYou are not responsible for enforcing compliance by third parties to\nthis License.\n\n 7. If, as a consequence of a court judgment or allegation of patent\ninfringement or for any other reason (not limited to patent issues),\nconditions are imposed on you (whether by court order, agreement or\notherwise) that contradict the conditions of this License, they do not\nexcuse you from the conditions of this License. If you cannot\ndistribute so as to satisfy simultaneously your obligations under this\nLicense and any other pertinent obligations, then as a consequence you\nmay not distribute the Program at all. For example, if a patent\nlicense would not permit royalty-free redistribution of the Program by\nall those who receive copies directly or indirectly through you, then\nthe only way you could satisfy both it and this License would be to\nrefrain entirely from distribution of the Program.\n\nIf any portion of this section is held invalid or unenforceable under\nany particular circumstance, the balance of the section is intended to\napply and the section as a whole is intended to apply in other\ncircumstances.\n\nIt is not the purpose of this section to induce you to infringe any\npatents or other property right claims or to contest validity of any\nsuch claims; this section has the sole purpose of protecting the\nintegrity of the free software distribution system, which is\nimplemented by public license practices. Many people have made\ngenerous contributions to the wide range of software distributed\nthrough that system in reliance on consistent application of that\nsystem; it is up to the author/donor to decide if he or she is willing\nto distribute software through any other system and a licensee cannot\nimpose that choice.\n\nThis section is intended to make thoroughly clear what is believed to\nbe a consequence of the rest of this License.\n\n 8. If the distribution and/or use of the Program is restricted in\ncertain countries either by patents or by copyrighted interfaces, the\noriginal copyright holder who places the Program under this License\nmay add an explicit geographical distribution limitation excluding\nthose countries, so that distribution is permitted only in or among\ncountries not thus excluded. In such case, this License incorporates\nthe limitation as if written in the body of this License.\n\n 9. The Free Software Foundation may publish revised and/or new versions\nof the General Public License from time to time. Such new versions will\nbe similar in spirit to the present version, but may differ in detail to\naddress new problems or concerns.\n\nEach version is given a distinguishing version number. If the Program\nspecifies a version number of this License which applies to it and \"any\nlater version\", you have the option of following the terms and conditions\neither of that version or of any later version published by the Free\nSoftware Foundation. If the Program does not specify a version number of\nthis License, you may choose any version ever published by the Free Software\nFoundation.\n\n 10. If you wish to incorporate parts of the Program into other free\nprograms whose distribution conditions are different, write to the author\nto ask for permission. For software which is copyrighted by the Free\nSoftware Foundation, write to the Free Software Foundation; we sometimes\nmake exceptions for this. Our decision will be guided by the two goals\nof preserving the free status of all derivatives of our free software and\nof promoting the sharing and reuse of software generally.\n\n\t\t\t NO WARRANTY\n\n 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY\nFOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN\nOTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES\nPROVIDE THE PROGRAM \"AS IS\" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED\nOR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\nMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS\nTO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE\nPROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,\nREPAIR OR CORRECTION.\n\n 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING\nWILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR\nREDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,\nINCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING\nOUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED\nTO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY\nYOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER\nPROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE\nPOSSIBILITY OF SUCH DAMAGES.\n\n\t\t END OF TERMS AND CONDITIONS\n\n================================\nApache License 2.0\n================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n===========\nMIT License\n===========\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n===============================================================================\n\nrules_boost_630cf5dbad418ee8cfa637b1e33125b11807721d (Provided under following license)\n===============================================================================\nApache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"{}\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright {yyyy} {name of copyright owner}\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n ===============================================================================\n===============================================================================\n\nlibnuma 2.0.14 (Provided under following license)\n===============================================================================\n\nThis package was debianized by Ian Wienand \non Wed, 15 Dec 2004.\n\nlibnuma sources are available from\nhttps://github.com/numactl/numactl\n\nUpstream Authors:\nAndi Kleen \n\nCopyright (C) 2004 Andi Kleen\n\nnumactl and the demo programs are under the GNU General Public License, v.2\nlibnuma is under the GNU Lesser General Public License, v2.1.\nThe manpages are under the same license as the Linux manpages (see the files)\n\nThis program is free software; you can redistribute it and/or modify\nit under the terms of the GNU General Public License as published\nby the Free Software Foundation; either version 2 of the License,\nor (at your option) any later version. The full text of the License\nmay be found in /usr/share/common-licenses/GPL.\n\nThe redistribution of portions of this program are controlled by\nthe GNU Lesser General Public License as published by the Free\nSoftware Foundation. The full text of the License may be found in\n/usr/share/common-licenses/LGPL.\n\nThis program is distributed in the hope that it will be useful,\nbut WITHOUT ANY WARRANTY; without even the implied warranty of\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\nGeneral Public License for more details.\n\nParts of the numademo program are derived from the STREAM benchmark,\navailable from\n\nhttp://www.cs.virginia.edu/stream/\n===============================================================================\n\nGitPython (Provided under following license)\n===============================================================================\n\nCopyright (C) 2008, 2009 Michael Trier and contributors\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions\nare met:\n\n* Redistributions of source code must retain the above copyright\nnotice, this list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright\nnotice, this list of conditions and the following disclaimer in the\ndocumentation and/or other materials provided with the distribution.\n\n* Neither the name of the GitPython project nor the names of\nits contributors may be used to endorse or promote products derived\nfrom this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\nLIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\nA PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\nOWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\nSPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED\nTO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\nPROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\nLIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\nNEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\nSOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n===============================================================================\n\nRAPIDS Memory Manager (RMM) (Provided under following license)\n===============================================================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n===============================================================================\n\nspdlog (Provided under following license)\n===============================================================================\n\nThe MIT License (MIT)\n\nCopyright (c) 2016 Gabi Melman.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n-- NOTE: Third party dependency used by this software --\nThis software depends on the fmt lib (MIT License),\nand users must comply to its license: https://raw.githubusercontent.com/fmtlib/fmt/master/LICENSE\n\n===============================================================================\n\nfmt (Provided under following license)\n===============================================================================\n\nCopyright (c) 2012 - present, Victor Zverovich and {fmt} contributors\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\nNONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\nLIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\nOF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\nWITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n--- Optional exception to the license ---\n\nAs an exception, if, as a result of your compiling your source code, portions\nof this Software are embedded into a machine-executable object form of such\nsource code, you may redistribute such embedded portions in such object form\nwithout including the above copyright and permission notices.\n\n===============================================================================\n\nyq (Provided under following license)\n===============================================================================\nApache License\nVersion 2.0, January 2004\nhttp://www.apache.org/licenses/\n\nTERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n1. Definitions.\n\n\"License\" shall mean the terms and conditions for use, reproduction, and\ndistribution as defined by Sections 1 through 9 of this document.\n\n\"Licensor\" shall mean the copyright owner or entity authorized by the copyright\nowner that is granting the License.\n\n\"Legal Entity\" shall mean the union of the acting entity and all other entities\nthat control, are controlled by, or are under common control with that entity.\nFor the purposes of this definition, \"control\" means (i) the power, direct or\nindirect, to cause the direction or management of such entity, whether by\ncontract or otherwise, or (ii) ownership of fifty percent (50%) or more of the\noutstanding shares, or (iii) beneficial ownership of such entity.\n\n\"You\" (or \"Your\") shall mean an individual or Legal Entity exercising\npermissions granted by this License.\n\n\"Source\" form shall mean the preferred form for making modifications, including\nbut not limited to software source code, documentation source, and configuration\nfiles.\n\n\"Object\" form shall mean any form resulting from mechanical transformation or\ntranslation of a Source form, including but not limited to compiled object code,\ngenerated documentation, and conversions to other media types.\n\n\"Work\" shall mean the work of authorship, whether in Source or Object form, made\navailable under the License, as indicated by a copyright notice that is included\nin or attached to the work (an example is provided in the Appendix below).\n\n\"Derivative Works\" shall mean any work, whether in Source or Object form, that\nis based on (or derived from) the Work and for which the editorial revisions,\nannotations, elaborations, or other modifications represent, as a whole, an\noriginal work of authorship. For the purposes of this License, Derivative Works\nshall not include works that remain separable from, or merely link (or bind by\nname) to the interfaces of, the Work and Derivative Works thereof.\n\n\"Contribution\" shall mean any work of authorship, including the original version\nof the Work and any modifications or additions to that Work or Derivative Works\nthereof, that is intentionally submitted to Licensor for inclusion in the Work\nby the copyright owner or by an individual or Legal Entity authorized to submit\non behalf of the copyright owner. For the purposes of this definition,\n\"submitted\" means any form of electronic, verbal, or written communication sent\nto the Licensor or its representatives, including but not limited to\ncommunication on electronic mailing lists, source code control systems, and\nissue tracking systems that are managed by, or on behalf of, the Licensor for\nthe purpose of discussing and improving the Work, but excluding communication\nthat is conspicuously marked or otherwise designated in writing by the copyright\nowner as \"Not a Contribution.\"\n\n\"Contributor\" shall mean Licensor and any individual or Legal Entity on behalf\nof whom a Contribution has been received by Licensor and subsequently\nincorporated within the Work.\n\n2. Grant of Copyright License.\n\nSubject to the terms and conditions of this License, each Contributor hereby\ngrants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,\nirrevocable copyright license to reproduce, prepare Derivative Works of,\npublicly display, publicly perform, sublicense, and distribute the Work and such\nDerivative Works in Source or Object form.\n\n3. Grant of Patent License.\n\nSubject to the terms and conditions of this License, each Contributor hereby\ngrants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,\nirrevocable (except as stated in this section) patent license to make, have\nmade, use, offer to sell, sell, import, and otherwise transfer the Work, where\nsuch license applies only to those patent claims licensable by such Contributor\nthat are necessarily infringed by their Contribution(s) alone or by combination\nof their Contribution(s) with the Work to which such Contribution(s) was\nsubmitted. If You institute patent litigation against any entity (including a\ncross-claim or counterclaim in a lawsuit) alleging that the Work or a\nContribution incorporated within the Work constitutes direct or contributory\npatent infringement, then any patent licenses granted to You under this License\nfor that Work shall terminate as of the date such litigation is filed.\n\n4. Redistribution.\n\nYou may reproduce and distribute copies of the Work or Derivative Works thereof\nin any medium, with or without modifications, and in Source or Object form,\nprovided that You meet the following conditions:\n\nYou must give any other recipients of the Work or Derivative Works a copy of\nthis License; and\nYou must cause any modified files to carry prominent notices stating that You\nchanged the files; and\nYou must retain, in the Source form of any Derivative Works that You distribute,\nall copyright, patent, trademark, and attribution notices from the Source form\nof the Work, excluding those notices that do not pertain to any part of the\nDerivative Works; and\nIf the Work includes a \"NOTICE\" text file as part of its distribution, then any\nDerivative Works that You distribute must include a readable copy of the\nattribution notices contained within such NOTICE file, excluding those notices\nthat do not pertain to any part of the Derivative Works, in at least one of the\nfollowing places: within a NOTICE text file distributed as part of the\nDerivative Works; within the Source form or documentation, if provided along\nwith the Derivative Works; or, within a display generated by the Derivative\nWorks, if and wherever such third-party notices normally appear. The contents of\nthe NOTICE file are for informational purposes only and do not modify the\nLicense. You may add Your own attribution notices within Derivative Works that\nYou distribute, alongside or as an addendum to the NOTICE text from the Work,\nprovided that such additional attribution notices cannot be construed as\nmodifying the License.\nYou may add Your own copyright statement to Your modifications and may provide\nadditional or different license terms and conditions for use, reproduction, or\ndistribution of Your modifications, or for any such Derivative Works as a whole,\nprovided Your use, reproduction, and distribution of the Work otherwise complies\nwith the conditions stated in this License.\n\n5. Submission of Contributions.\n\nUnless You explicitly state otherwise, any Contribution intentionally submitted\nfor inclusion in the Work by You to the Licensor shall be under the terms and\nconditions of this License, without any additional terms or conditions.\nNotwithstanding the above, nothing herein shall supersede or modify the terms of\nany separate license agreement you may have executed with Licensor regarding\nsuch Contributions.\n\n6. Trademarks.\n\nThis License does not grant permission to use the trade names, trademarks,\nservice marks, or product names of the Licensor, except as required for\nreasonable and customary use in describing the origin of the Work and\nreproducing the content of the NOTICE file.\n\n7. Disclaimer of Warranty.\n\nUnless required by applicable law or agreed to in writing, Licensor provides the\nWork (and each Contributor provides its Contributions) on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,\nincluding, without limitation, any warranties or conditions of TITLE,\nNON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are\nsolely responsible for determining the appropriateness of using or\nredistributing the Work and assume any risks associated with Your exercise of\npermissions under this License.\n\n8. Limitation of Liability.\n\nIn no event and under no legal theory, whether in tort (including negligence),\ncontract, or otherwise, unless required by applicable law (such as deliberate\nand grossly negligent acts) or agreed to in writing, shall any Contributor be\nliable to You for damages, including any direct, indirect, special, incidental,\nor consequential damages of any character arising as a result of this License or\nout of the use or inability to use the Work (including but not limited to\ndamages for loss of goodwill, work stoppage, computer failure or malfunction, or\nany and all other commercial damages or losses), even if such Contributor has\nbeen advised of the possibility of such damages.\n\n9. Accepting Warranty or Additional Liability.\n\nWhile redistributing the Work or Derivative Works thereof, You may choose to\noffer, and charge a fee for, acceptance of support, warranty, indemnity, or\nother liability obligations and/or rights consistent with this License. However,\nin accepting such obligations, You may act only on Your own behalf and on Your\nsole responsibility, not on behalf of any other Contributor, and only if You\nagree to indemnify, defend, and hold each Contributor harmless for any liability\nincurred by, or claims asserted against, such Contributor by reason of your\naccepting any such warranty or additional liability.\n\nEND OF TERMS AND CONDITIONS\n\nAPPENDIX: How to apply the Apache License to your work\n\nTo apply the Apache License to your work, attach the following boilerplate\nnotice, with the fields enclosed by brackets \"[]\" replaced with your own\nidentifying information. (Don't include the brackets!) The text should be\nenclosed in the appropriate comment syntax for the file format. We also\nrecommend that a file or class name and description of purpose be included on\nthe same \"printed page\" as the copyright notice for easier identification within\nthird-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n===============================================================================\n\nbazelbuild/bazel-gazelle 0.24.0 (Provided under following license)\n===============================================================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n===============================================================================\n\nbazelbuild/rules_go 0.24.2 (Provided under following license)\n===============================================================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n===============================================================================\n\nbazelbuild/rules_docker 0.22.0 (Provided under following license)\n===============================================================================\n\n Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"{}\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright {yyyy} {name of copyright owner}\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n\n===============================================================================\n" }, { "path": "isaac_ros_gxf/package.xml", "content": "\n\n\n\n\n\n isaac_ros_gxf\n 4.4.0\n Isaac ROS GXF\n\n Isaac ROS Maintainers\n NVIDIA Isaac ROS Software License\n https://developer.nvidia.com/isaac-ros-gems/\n CY Chen\n Swapnesh Wani\n\n ament_cmake\n\n magic_enum\n libucx0\n nvsci\n libgnat-23\n\n isaac_ros_common\n\n ament_lint_auto\n ament_lint_common\n\n \n ament_cmake\n \n\n" }, { "path": "isaac_ros_gxf/src/isaac_ros_gxf.cpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n// Placeholder to allow ament_cmake_lint to not error on no source files.\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_argus/CMakeLists.txt", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\ncmake_minimum_required(VERSION 3.22.1)\nproject(gxf_isaac_argus LANGUAGES C CXX)\n\nif(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n add_compile_options(-Wall -Wextra -Wpedantic)\nendif()\n\nfind_package(ament_cmake_auto REQUIRED)\nament_auto_find_build_dependencies()\n\n# Determine the architecture\nif(CMAKE_SYSTEM_PROCESSOR MATCHES \"aarch64\")\n if(CMAKE_DEVICE STREQUAL \"sbsa\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_aarch64_cuda_13_0\")\n elseif(CMAKE_DEVICE STREQUAL \"arm64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_jetpack70\")\n else()\n message(FATAL_ERROR \"Device is not supported.\")\n endif()\nendif()\n\n# Add an interface target to export dependencies\nadd_library(${PROJECT_NAME} INTERFACE)\n\n# Install shared library\nif(EXISTS \"${GXF_EXT_LIB_PATH}/lib${PROJECT_NAME}.so\")\n install(FILES \"${GXF_EXT_LIB_PATH}/lib${PROJECT_NAME}.so\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/lib\")\n set_property(TARGET ${PROJECT_NAME} PROPERTY\n INTERFACE_LINK_LIBRARIES\n \"$/share/${PROJECT_NAME}/gxf/lib/lib${PROJECT_NAME}.so\"\n )\nendif()\n\n# Install headers\nif(EXISTS \"${CMAKE_CURRENT_SOURCE_DIR}/gxf\")\n install(DIRECTORY \"${CMAKE_CURRENT_SOURCE_DIR}/gxf/\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/include\")\n set_target_properties(${PROJECT_NAME} PROPERTIES\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\")\nendif()\n\ninstall(TARGETS ${PROJECT_NAME}\n EXPORT export_${PROJECT_NAME}\n LIBRARY DESTINATION lib\n ARCHIVE DESTINATION lib\n RUNTIME DESTINATION bin)\nament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)\n\n\n# Embed versioning information into installed files\nament_index_get_resource(ISAAC_ROS_COMMON_CMAKE_PATH isaac_ros_common_cmake_path isaac_ros_common)\ninclude(\"${ISAAC_ROS_COMMON_CMAKE_PATH}/isaac_ros_common-version-info.cmake\")\ngenerate_version_info(${PROJECT_NAME})\n\nament_auto_package(INSTALL_TO_SHARE)" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_argus/package.xml", "content": "\n\n\n\n\n\n gxf_isaac_argus\n 4.4.0\n GXF extension containing argus components.\n\n Isaac ROS Maintainers\n Apache-2.0\n https://developer.nvidia.com/isaac-ros-gems/\n CY Chen\n\n ament_cmake_auto\n\n isaac_ros_common\n\n isaac_ros_gxf\n\n ament_lint_auto\n ament_lint_common\n\n \n ament_cmake\n \n\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_atlas/CMakeLists.txt", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\ncmake_minimum_required(VERSION 3.22.1)\nproject(gxf_isaac_atlas LANGUAGES C CXX)\n\nif(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n add_compile_options(-Wall -Wextra -Wpedantic)\nendif()\n\nfind_package(ament_cmake_auto REQUIRED)\nament_auto_find_build_dependencies()\n\n# Determine the architecture\nif(CMAKE_SYSTEM_PROCESSOR MATCHES \"aarch64\")\n if(CMAKE_DEVICE STREQUAL \"sbsa\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_aarch64_cuda_13_0\")\n elseif(CMAKE_DEVICE STREQUAL \"arm64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_jetpack70\")\n else()\n message(FATAL_ERROR \"Device is not supported.\")\n endif()\nelseif(CMAKE_SYSTEM_PROCESSOR MATCHES \"x86_64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_x86_64_cuda_13_0\")\nelse()\n message(FATAL_ERROR \"Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}\")\nendif()\n\n# Add an interface target to export dependencies\nadd_library(${PROJECT_NAME} INTERFACE)\n\n# Install shared library\ninstall(FILES \"${GXF_EXT_LIB_PATH}/lib${PROJECT_NAME}.so\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/lib\")\nset_property(TARGET ${PROJECT_NAME} PROPERTY\n INTERFACE_LINK_LIBRARIES\n \"$/share/${PROJECT_NAME}/gxf/lib/lib${PROJECT_NAME}.so\"\n)\n\n# Install headers\nif(EXISTS \"${CMAKE_CURRENT_SOURCE_DIR}/gxf\")\n install(DIRECTORY \"${CMAKE_CURRENT_SOURCE_DIR}/gxf/\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/include\")\n set_target_properties(${PROJECT_NAME} PROPERTIES\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\")\nendif()\n\ninstall(TARGETS ${PROJECT_NAME}\n EXPORT export_${PROJECT_NAME}\n LIBRARY DESTINATION lib\n ARCHIVE DESTINATION lib\n RUNTIME DESTINATION bin)\nament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)\n\n\n# Embed versioning information into installed files\nament_index_get_resource(ISAAC_ROS_COMMON_CMAKE_PATH isaac_ros_common_cmake_path isaac_ros_common)\ninclude(\"${ISAAC_ROS_COMMON_CMAKE_PATH}/isaac_ros_common-version-info.cmake\")\ngenerate_version_info(${PROJECT_NAME})\n\nament_auto_package(INSTALL_TO_SHARE)\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_atlas/gxf/extensions/atlas/composite_schema_server.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"common/unique_index_map.hpp\"\n#include \"gems/composite/schema.hpp\"\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// CompositeSchemaServer is a central repository for storing composite schemas across multiple\n// components. When a Schema is loaded to the server, the server will then provide an 64 bit key\n// that is guaranteed to be unique for the lifetime of the CompositeSchemaServer. This allows\n// components to pass composite messages along with the key, rather than needing to encode the whole\n// Schema in the message.\nclass CompositeSchemaServer : public gxf::Component {\n public:\n gxf_result_t registerInterface(gxf::Registrar* registrar) override;\n gxf_result_t initialize() override;\n\n // Stores a schema into the server and returns a unique ID tied to the schema.\n gxf::Expected add(const composite::Schema& schema);\n\n // Retrieves a schema from the server using the provided unique ID.\n gxf::Expected get(uint64_t uid) const;\n\n // Returns true if the unique index map is at maximum capacity.\n bool full() const { return (schemas_.size() == schemas_.capacity()); }\n\n private:\n gxf::Parameter maximum_capacity_;\n\n // Map of uint64_t to schemas that provides unique keys for every insert.\n UniqueIndexMap schemas_;\n\n // Protect from concurrent read/write access to the schemas_.\n mutable std::mutex mutex_;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_atlas/gxf/extensions/atlas/pose_tree_frame.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"extensions/gxf_helpers/parameter_parser_isaac.hpp\"\n#include \"extensions/gxf_helpers/parameter_wrapper_isaac.hpp\"\n#include \"extensions/gxf_helpers/string_provider.hpp\"\n#include \"gems/core/math/pose3.hpp\"\n#include \"gems/core/optional.hpp\"\n#include \"gems/pose_tree/pose_tree.hpp\"\n#include \"gxf/core/component.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Creates a frame in the PoseTree with given name. Optionally sets its pose. Provides methods to\n// access its name and uid.\nclass PoseTreeFrame : public gxf::Component {\n public:\n gxf_result_t registerInterface(gxf::Registrar* registrar) override;\n gxf_result_t initialize() override;\n gxf_result_t deinitialize() override;\n\n // Returns UID of the frame\n PoseTree::frame_t frame_uid() const { return frame_uid_; }\n // Returns name of the frame\n const char* frame_name() const { return frame_name_string_.c_str(); }\n // Returns name of the parent frame\n const char* parent_frame_name() const;\n // Retursn whether the frame can be moved using interactive markers.\n bool interactive_marker() const { return interactive_marker_; }\n\n private:\n // Sets up the frame in PoseTree with given parameters, if it has not already. This function can\n // be called by the initialize() of this component or by the initialize() of other PoseTreeFrame\n // components, but it executes once per initialization.\n gxf_result_t setup();\n\n gxf::Parameter frame_name_;\n gxf::Parameter number_edges_;\n gxf::Parameter> parent_frame_;\n gxf::Parameter<::nvidia::isaac::Pose3d> initial_pose_;\n gxf::Parameter invert_pose_;\n gxf::Parameter maximum_edge_history_;\n gxf::Parameter> pose_tree_;\n gxf::Parameter> namespace_;\n gxf::Parameter interactive_marker_;\n\n // The value returned by setup() function. Cleared at deinitialize().\n std::optional setup_result_ = std::nullopt;\n // Cached values\n PoseTree::frame_t frame_uid_;\n std::string frame_name_string_;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_atlas/package.xml", "content": "\n\n\n\n\n\n gxf_isaac_atlas\n 4.4.0\n GXF extension containing environment management components, such as pose tree, map providers, and the composite schema server.\n\n Isaac ROS Maintainers\n Apache-2.0\n https://developer.nvidia.com/isaac-ros-gems/\n CY Chen\n\n ament_cmake_auto\n\n isaac_ros_common\n isaac_ros_gxf\n gxf_isaac_gems\n\n ament_lint_auto\n ament_lint_common\n\n \n ament_cmake\n \n\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/CMakeLists.txt", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\ncmake_minimum_required(VERSION 3.22.1)\nproject(gxf_isaac_camera_utils LANGUAGES C CXX)\n\nif(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n add_compile_options(-Wall -Wextra -Wpedantic)\nendif()\n\nfind_package(ament_cmake_auto REQUIRED)\nament_auto_find_build_dependencies()\n\n# Dependencies\nfind_package(CUDAToolkit REQUIRED)\nfind_package(Eigen3 3.3 REQUIRED NO_MODULE)\nfind_package(yaml-cpp)\n\n# Camera utils extension\nament_auto_add_library(${PROJECT_NAME} SHARED\n gxf/extensions/camera_utils/camera_utils.cpp\n gxf/extensions/camera_utils/stereo_camera_synchronizer.cpp\n gxf/extensions/camera_utils/stereo_camera_synchronizer.hpp\n gxf/extensions/camera_utils/camera_info_synchronizer.cpp\n gxf/extensions/camera_utils/camera_info_synchronizer.hpp\n)\ntarget_include_directories(${PROJECT_NAME} PUBLIC \"${CMAKE_CURRENT_SOURCE_DIR}/gxf\")\ntarget_link_libraries(${PROJECT_NAME}\n Eigen3::Eigen\n yaml-cpp\n)\nset_target_properties(${PROJECT_NAME} PROPERTIES\n BUILD_WITH_INSTALL_RPATH TRUE\n BUILD_RPATH_USE_ORIGIN TRUE\n INSTALL_RPATH_USE_LINK_PATH TRUE\n)\n\n# Install the binary file\ninstall(TARGETS ${PROJECT_NAME} DESTINATION share/${PROJECT_NAME}/gxf/lib)\n\n\n# Embed versioning information into installed files\nament_index_get_resource(ISAAC_ROS_COMMON_CMAKE_PATH isaac_ros_common_cmake_path isaac_ros_common)\ninclude(\"${ISAAC_ROS_COMMON_CMAKE_PATH}/isaac_ros_common-version-info.cmake\")\ngenerate_version_info(${PROJECT_NAME})\n\nament_auto_package(INSTALL_TO_SHARE)\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/camera_info_synchronizer.cpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#include \"camera_info_synchronizer.hpp\"\n\n#include \n#include \n#include \n\n#include \"gxf/core/expected_macro.hpp\"\n#include \"gxf/std/timestamp.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\nnamespace {\n// Global constants that detail sync behavior\nsize_t kSyncOldestOnFastestQueue = 0;\nsize_t kSyncNewestOnSlowestQueue = 1;\n} // namespace\n\ngxf_result_t\nCameraInfoSynchronization::registerInterface(gxf::Registrar* registrar) {\n gxf::Expected result;\n result &= registrar->parameter(camera_message_rx_, \"camera_message_rx\",\n \"Camera Message receiver\",\n \"Camera message receiver handle.\");\n result &= registrar->parameter(\n camera_info_message_rx_, \"camera_info_message_rx\",\n \"Camera Info message receiver\", \"Camera info message receiver handle.\");\n result &= registrar->parameter(camera_message_tx_, \"camera_message_tx\",\n \"Camera Message transmitter\",\n \"Camera message transmitter handle.\");\n result &= registrar->parameter(camera_info_message_tx_, \"camera_info_message_tx\",\n \"Camera Info message transmitter\",\n \"Camera info message transmitter handle.\");\n result &= registrar->parameter(use_latest_camera_info_, \"use_latest_camera_info\",\n \"Use latest camera info\",\n \"Use latest camera info message, make time stamp \"\n \"same as image and forward\",\n false);\n result &= registrar->parameter(drop_old_messages_, \"drop_old_messages\",\n \"Drop oldest messages inside tick function\",\n \"Drop oldest messages inside tick function\", false);\n result &= registrar->parameter(\n sync_policy_, \"sync_policy\", \"Synchronization policy\",\n \"Synchronization policy, 0: choose oldest message from fastest moving queue\"\n \"1: choose newest message from slowest moving queue. 0 is good for processing most of the\"\n \"data at the cost of being potentially slower than realtime. 1 is good for finding sync\"\n \"points close to real time but at the cost of dropping more data.\",\n static_cast(0));\n\n return gxf::ToResultCode(result);\n}\n\ngxf_result_t CameraInfoSynchronization::start() {\n camera_acq_times_.reserve(camera_message_rx_->capacity());\n camera_info_acq_times_.reserve(camera_info_message_rx_->capacity());\n return GXF_SUCCESS;\n}\n\ngxf_result_t CameraInfoSynchronization::dropOldestMessagesIfQueueIsFull() {\n // Clear all queues\n RETURN_IF_ERROR(camera_message_rx_->sync());\n if (camera_message_rx_->size() == camera_message_rx_->capacity()) {\n // If you see this log, please disable the drop_old_messages parameter and make sure your\n // GXF node is the first entry point into the Nitros graph. The Nitros graph will force add\n // a policy 0 on all incoming receivers and will drop messages if the queue is full.\n // This log is to inform the user that they might be unintentionally dropping messages.\n GXF_LOG_WARNING(\"Dropping messages from camera message receiver\");\n RETURN_IF_ERROR(camera_message_rx_->receive());\n }\n RETURN_IF_ERROR(camera_info_message_rx_->sync());\n if (camera_info_message_rx_->size() == camera_info_message_rx_->capacity()) {\n // If you see this log, please disable the drop_old_messages parameter and make sure your\n // GXF node is the first entry point into the Nitros graph. The Nitros graph will force add\n // a policy 0 on all incoming receivers and will drop messages if the queue is full.\n // This log is to inform the user that they might be unintentionally dropping messages.\n GXF_LOG_WARNING(\"Dropping messages from camera info message receiver\");\n RETURN_IF_ERROR(camera_info_message_rx_->receive());\n }\n return GXF_SUCCESS;\n}\n\ngxf_result_t CameraInfoSynchronization::useLatestCameraInfo() {\n bool all_messages_available = true;\n\n RETURN_IF_ERROR(camera_message_rx_->sync());\n if (camera_message_rx_->size() == 0) {\n GXF_LOG_DEBUG(\n \"Camera message receiver has no messages for synchronization!\");\n all_messages_available = false;\n }\n\n RETURN_IF_ERROR(camera_info_message_rx_->sync());\n if (camera_info_message_rx_->size() == 0) {\n GXF_LOG_DEBUG(\n \"Camera info message receiver has no messages for synchronization!\");\n all_messages_available = false;\n }\n\n if (!all_messages_available && drop_old_messages_.get()) {\n // We do this to keep the graph ticking and not leading to blocks.\n // To enable no dropping of messages, users are requested to use individual\n // MessageAvailableSchedulingTerms for each rx. We do not need to do this if used as the first\n // input in a Nitros node because Nitros adds a policy: 0 to the input rx of the graph\n // automatically.\n return dropOldestMessagesIfQueueIsFull();\n } else if (!all_messages_available) {\n // Do not do anything if not all messages are available\n return GXF_SUCCESS;\n }\n\n gxf::Entity camera_message = UNWRAP_OR_RETURN(camera_message_rx_->receive());\n gxf::Entity camera_info_message = UNWRAP_OR_RETURN(camera_info_message_rx_->receive());\n\n // Make camera info timestamp same as camera message\n auto timestamp_components_cam = camera_message.findAllHeap();\n auto acq_time = timestamp_components_cam->front().value()->acqtime;\n\n // This will publish the camera and camera info messages with the same\n // timestamp. This might be required upstream by some codelets\n camera_message_tx_->publish(camera_message, acq_time);\n camera_info_message_tx_->publish(camera_info_message, acq_time);\n\n return GXF_SUCCESS;\n}\n\ngxf_result_t syncMessages(const std::vector& acq_times,\n const gxf::Handle& rx,\n const gxf::Handle& tx,\n const int64_t candidate_sync_point) {\n for (size_t index = acq_times.size(); index > 0; index--) {\n if (acq_times[index-1] == candidate_sync_point) {\n gxf::Entity message = UNWRAP_OR_RETURN(rx->receive());\n RETURN_IF_ERROR(tx->publish(message));\n return GXF_SUCCESS;\n } else if (acq_times[index-1] < candidate_sync_point) {\n // Old message, drop it\n RETURN_IF_ERROR(rx->receive());\n } else if (acq_times[index-1] > candidate_sync_point) {\n // This should not happen\n GXF_LOG_ERROR(\"Message timestamp is not monotonically increasing\");\n return GXF_FAILURE;\n }\n }\n GXF_LOG_ERROR(\"Did not publish anything, should have published\");\n return GXF_FAILURE;\n}\n\ngxf_result_t CameraInfoSynchronization::tick() {\n // Clear all queues for processing in this tick call\n camera_acq_times_.clear();\n camera_info_acq_times_.clear();\n\n if (use_latest_camera_info_.get()) {\n return useLatestCameraInfo();\n }\n // Check if all input queues have messages\n bool all_messages_available = true;\n RETURN_IF_ERROR(camera_message_rx_->sync());\n RETURN_IF_ERROR(camera_info_message_rx_->sync());\n if (camera_message_rx_->size() == 0 || camera_info_message_rx_->size() == 0) {\n // Not all the inputs have messages, unexpected.\n GXF_LOG_DEBUG(\"Not all the inputs have messages for synchronization!\");\n all_messages_available = false;\n }\n\n if (!all_messages_available && drop_old_messages_.get()) {\n // Acts as a policy inside the tick function\n return dropOldestMessagesIfQueueIsFull();\n } else if (!all_messages_available) {\n // Do not do anything if not all messages are available\n return GXF_SUCCESS;\n }\n\n // Read the timestamps of available messages from camera input\n for (size_t index = camera_message_rx_->size(); index > 0; index--) {\n auto msg_result = camera_message_rx_->peek(index - 1);\n if (msg_result) {\n auto timestamp_components = msg_result->findAllHeap();\n if (!timestamp_components) {\n return gxf::ToResultCode(timestamp_components);\n }\n if (0 == timestamp_components->size()) {\n GXF_LOG_ERROR(\"No timestamp found from the camera message\");\n return GXF_ENTITY_COMPONENT_NOT_FOUND;\n }\n camera_acq_times_.push_back(\n timestamp_components->front().value()->acqtime);\n }\n }\n\n // Read the timestamps of available messages from camera info input\n for (size_t index = camera_info_message_rx_->size(); index > 0; index--) {\n auto msg_result = camera_info_message_rx_->peek(index - 1);\n if (msg_result) {\n auto timestamp_components = msg_result->findAllHeap();\n if (!timestamp_components) {\n return gxf::ToResultCode(timestamp_components);\n }\n if (0 == timestamp_components->size()) {\n GXF_LOG_ERROR(\"No timestamp found from the camera info message\");\n return GXF_ENTITY_COMPONENT_NOT_FOUND;\n }\n camera_info_acq_times_.push_back(\n timestamp_components->front().value()->acqtime);\n }\n }\n\n if (camera_acq_times_.size() == 0 || camera_info_acq_times_.size() == 0) {\n GXF_LOG_ERROR(\"This array should not be empty at this stage\");\n return GXF_FAILURE;\n }\n\n int64_t candidate_sync_point = std::numeric_limits::max();\n if (sync_policy_.get() == kSyncNewestOnSlowestQueue) {\n /* Find newest timestamp from slowest moving queue, this makes sure with\n the messages we have we will find a sync point closest to real time, and\n not the potential non optimal time chosen by oldest message in fastest\n moving queue\n Each timestamps.front() is the newest message from that queue.We pick the minimum of\n these newest timestamps\n */\n if (!camera_acq_times_.empty() && camera_acq_times_.front() < candidate_sync_point) {\n candidate_sync_point = camera_acq_times_.front();\n }\n if (!camera_info_acq_times_.empty() && camera_info_acq_times_.front() < candidate_sync_point) {\n candidate_sync_point = camera_info_acq_times_.front();\n }\n } else if (sync_policy_.get() == kSyncOldestOnFastestQueue) {\n // find oldest timestamp we're going to pick from the fastest moving queue\n candidate_sync_point = 0;\n if (camera_acq_times_.back() > candidate_sync_point) {\n candidate_sync_point = camera_acq_times_.back();\n }\n if (camera_info_acq_times_.back() > candidate_sync_point) {\n candidate_sync_point = camera_info_acq_times_.back();\n }\n }\n\n bool found_in_camera_queue = false;\n bool found_in_camera_info_queue = false;\n for (auto it = camera_acq_times_.begin(); it != camera_acq_times_.end(); it++) {\n if (*it == candidate_sync_point) {\n found_in_camera_queue = true;\n }\n }\n for (auto it = camera_info_acq_times_.begin(); it != camera_info_acq_times_.end(); it++) {\n if (*it == candidate_sync_point) {\n found_in_camera_info_queue = true;\n }\n }\n\n if (!found_in_camera_queue || !found_in_camera_info_queue) {\n GXF_LOG_DEBUG(\"Did not find candidate sync point in one of the input queues\");\n return GXF_SUCCESS;\n }\n\n GXF_LOG_DEBUG(\"Candidate timestamp for syncing (from camera queue): %zd\",\n candidate_sync_point);\n RETURN_IF_ERROR(syncMessages(camera_info_acq_times_, camera_info_message_rx_,\n camera_info_message_tx_, candidate_sync_point));\n RETURN_IF_ERROR(syncMessages(camera_acq_times_, camera_message_rx_,\n camera_message_tx_, candidate_sync_point));\n return GXF_SUCCESS;\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/camera_info_synchronizer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gxf/core/gxf.h\"\n\n#include \"common/assert.hpp\"\n#include \"common/type_name.hpp\"\n#include \"gxf/core/handle.hpp\"\n#include \"gxf/core/parameter_parser_std.hpp\"\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// A codelet to sync camera messages with camera info messages. It will match the timestamp of a\n// camera info message with the timestamp of the corresponding camera message. If the parameter\n// for use_latest_camera_info is set to true, it will use the latest camera info message\n// It will make sure to update the camera info message with the same timestamp as that of the\n// camera message\nclass CameraInfoSynchronization : public gxf::Codelet {\n public:\n gxf_result_t registerInterface(gxf::Registrar* registrar) override;\n gxf_result_t start() override;\n gxf_result_t tick() override;\n // This function will drop oldest messages from either queues to keep the graph ticking.\n // It is needed when a user decides to use this codelet with a MultiMessageAvailableScheduling\n // term.\n gxf_result_t dropOldestMessagesIfQueueIsFull();\n // Gets latest camera info is in the queues and matches it with the image. It will update\n // timestamp of the camera info message to be the same as that of the camera message.\n gxf_result_t useLatestCameraInfo();\n\n private:\n gxf::Parameter> camera_message_rx_;\n gxf::Parameter> camera_info_message_rx_;\n gxf::Parameter> camera_message_tx_;\n gxf::Parameter> camera_info_message_tx_;\n gxf::Parameter use_latest_camera_info_;\n gxf::Parameter drop_old_messages_;\n gxf::Parameter sync_policy_;\n // These parameters are used to store the timestamps of the camera and camera info messages\n // These are preallocated in the start function to not have memory access during runtime\n std::vector camera_acq_times_;\n std::vector camera_info_acq_times_;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/camera_utils.cpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#include \"extensions/camera_utils/camera_info_synchronizer.hpp\"\n#include \"extensions/camera_utils/stereo_camera_synchronizer.hpp\"\n#include \"gxf/std/extension_factory_helper.hpp\"\n\nGXF_EXT_FACTORY_BEGIN()\n\nGXF_EXT_FACTORY_SET_INFO(0xa722f33021690730, 0x8efa17986d37641d, \"NvIsaacCameraUtilsExtension\",\n \"Extension containing miscellaneous camera utility components\",\n \"Isaac SDK\", \"2.0.0\", \"LICENSE\");\n\nGXF_EXT_FACTORY_ADD(0x8760c3e2306c1ff6, 0xb9f0fb97cef0110f,\n nvidia::isaac::StereoCameraSynchronizer, nvidia::gxf::Codelet,\n \"Copies timestamp from left input msg to right input msg\");\n\nGXF_EXT_FACTORY_ADD(0x8760c3e2306c2ff6, 0xb9f0fb97cef0210f,\n nvidia::isaac::CameraInfoSynchronization, nvidia::gxf::Codelet,\n \"Synchronizes camera info and camera message, uses cached camera info if \"\n \"needed\");\n\nGXF_EXT_FACTORY_END()\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/stereo_camera_synchronizer.cpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n\n#include \"stereo_camera_synchronizer.hpp\"\n\n#include \n\n#include \"gems/gxf_helpers/expected_macro_gxf.hpp\"\n#include \"gxf/std/timestamp.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\ngxf_result_t StereoCameraSynchronizer::registerInterface(gxf::Registrar* registrar) {\n gxf::Expected result;\n result &= registrar->parameter(\n rx_right_camera_, \"rx_right_camera\", \"RX Right Camera Message\",\n \"Input for Right CameraMessage entities\");\n result &= registrar->parameter(\n rx_left_camera_, \"rx_left_camera\", \"RX Left Camera Message\",\n \"Input for Left CameraMessage entities\");\n result &= registrar->parameter(\n tx_right_camera_, \"tx_right_camera\", \"TX Right Camera Message\",\n \"Input for Right CameraMessage entities\");\n result &= registrar->parameter(\n tx_left_camera_, \"tx_left_camera\", \"TX Left Camera Message\",\n \"Input for Left CameraMessage entities\");\n result &= registrar->parameter(\n max_timestamp_diff_, \"max_timestamp_diff\", \"Max difference timestamps nanoseconds\",\n \"Max difference between timestamps in nanoseconds\",\n static_cast(200000)); // 200 micro seconds\n return gxf::ToResultCode(result);\n}\n\ngxf_result_t StereoCameraSynchronizer::start() {\n // Set all previous timestamps to minimum value of int64_t\n // This ensures that the first message received does NOT trigger the\n // \"not monotonically increasing\" error\n prev_left_unnamed_timestamp_ = std::numeric_limits::min();\n prev_right_unnamed_timestamp_ = std::numeric_limits::min();\n prev_left_named_timestamp_ = std::numeric_limits::min();\n prev_right_named_timestamp_ = std::numeric_limits::min();\n return GXF_SUCCESS;\n}\n\ngxf_result_t StereoCameraSynchronizer::tick() {\n auto left_camera_entity = UNWRAP_OR_RETURN(rx_left_camera_->receive());\n auto right_camera_entity = UNWRAP_OR_RETURN(rx_right_camera_->receive());\n auto left_unnamed_timestamp = UNWRAP_OR_RETURN(left_camera_entity.get());\n auto right_unnamed_timestamp = UNWRAP_OR_RETURN(right_camera_entity.get());\n auto left_named_timestamp = UNWRAP_OR_RETURN(left_camera_entity.get(\"timestamp\"));\n auto right_named_timestamp = UNWRAP_OR_RETURN(\n right_camera_entity.get(\"timestamp\"));\n\n const int64_t unnamed_diff = std::abs(left_unnamed_timestamp->acqtime -\n right_unnamed_timestamp->acqtime);\n if (unnamed_diff > max_timestamp_diff_) {\n GXF_LOG_ERROR(\"L/R frames are not synchronized, unnamed timestamp diff = %ld ns\", unnamed_diff);\n return GXF_FAILURE;\n }\n\n const int64_t named_diff = std::abs(left_named_timestamp->acqtime -\n right_named_timestamp->acqtime);\n if (named_diff > max_timestamp_diff_) {\n GXF_LOG_ERROR(\"L/R frames are not synchronized, named timestamp diff = %ld ns\", named_diff);\n return GXF_FAILURE;\n }\n // Set right input timestamp to left input timestamp\n right_unnamed_timestamp->acqtime = left_unnamed_timestamp->acqtime;\n right_named_timestamp->acqtime = left_named_timestamp->acqtime;\n\n\n // Check if previous timestamp is lower than current timestamp\n if (prev_left_unnamed_timestamp_ > left_unnamed_timestamp->acqtime) {\n GXF_LOG_ERROR(\"Left unnamed timestamp is not monotonically increasing\");\n return GXF_FAILURE;\n }\n if (prev_right_unnamed_timestamp_ > right_unnamed_timestamp->acqtime) {\n GXF_LOG_ERROR(\"Right unnamed timestamp is not monotonically increasing\");\n return GXF_FAILURE;\n }\n if (prev_left_named_timestamp_ > left_named_timestamp->acqtime) {\n GXF_LOG_ERROR(\"Left named timestamp is not monotonically increasing\");\n return GXF_FAILURE;\n }\n if (prev_right_named_timestamp_ > right_named_timestamp->acqtime) {\n GXF_LOG_ERROR(\"Right named timestamp is not monotonically increasing\");\n return GXF_FAILURE;\n }\n\n prev_left_unnamed_timestamp_ = left_unnamed_timestamp->acqtime;\n prev_right_unnamed_timestamp_ = right_unnamed_timestamp->acqtime;\n prev_left_named_timestamp_ = left_named_timestamp->acqtime;\n prev_right_named_timestamp_ = right_named_timestamp->acqtime;\n\n RETURN_IF_ERROR(tx_left_camera_->publish(left_camera_entity));\n RETURN_IF_ERROR(tx_right_camera_->publish(right_camera_entity));\n\n return GXF_SUCCESS;\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/stereo_camera_synchronizer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gxf/std/codelet.hpp\"\n#include \"gxf/std/receiver.hpp\"\n#include \"gxf/std/transmitter.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// This codelet checks if stereo frames timestamps are within a tolerance and\n// will edit the right input timestamps to match the left input timestamp\n// Some downstream applications expect matched stereo frames to have exactly the same timestamp\n// even though in reality matched frames can differ by a few microseconds.\nclass StereoCameraSynchronizer : public gxf::Codelet {\n gxf_result_t registerInterface(gxf::Registrar* registrar) override;\n gxf_result_t start() override;\n gxf_result_t tick() override;\n gxf_result_t stop() override { return GXF_SUCCESS; }\n\n private:\n gxf::Parameter> rx_right_camera_;\n gxf::Parameter> rx_left_camera_;\n gxf::Parameter> tx_right_camera_;\n gxf::Parameter> tx_left_camera_;\n gxf::Parameter max_timestamp_diff_;\n int64_t prev_left_unnamed_timestamp_, prev_right_unnamed_timestamp_;\n int64_t prev_left_named_timestamp_, prev_right_named_timestamp_;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/package.xml", "content": "\n\n\n\n\n\n gxf_isaac_camera_utils\n 4.4.0\n NvIsaacCameraUtilsExtension\n\n Isaac ROS Maintainers\n Apache-2.0\n https://developer.nvidia.com/isaac-ros-gems/\n CY Chen\n\n ament_cmake_auto\n\n isaac_ros_common\n isaac_ros_gxf\n gxf_isaac_messages\n gxf_isaac_tensorops\n isaac-ros-cli\n tensorrt\n\n gxf_isaac_gems\n\n ament_lint_auto\n ament_lint_common\n\n \n ament_cmake\n \n\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_cuda/CMakeLists.txt", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\ncmake_minimum_required(VERSION 3.22.1)\nproject(gxf_isaac_cuda LANGUAGES C CXX)\n\nif(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n add_compile_options(-Wall -Wextra -Wpedantic)\nendif()\n\nfind_package(ament_cmake_auto REQUIRED)\nament_auto_find_build_dependencies()\n\n# Determine the architecture\nif(CMAKE_SYSTEM_PROCESSOR MATCHES \"aarch64\")\n if(CMAKE_DEVICE STREQUAL \"sbsa\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_aarch64_cuda_13_0\")\n elseif(CMAKE_DEVICE STREQUAL \"arm64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_jetpack70\")\n else()\n message(FATAL_ERROR \"Device is not supported.\")\n endif()\nelseif(CMAKE_SYSTEM_PROCESSOR MATCHES \"x86_64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_x86_64_cuda_13_0\")\nelse()\n message(FATAL_ERROR \"Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}\")\nendif()\n\n# Add an interface target to export dependencies\nadd_library(${PROJECT_NAME} INTERFACE)\n\n# Install shared library\ninstall(FILES \"${GXF_EXT_LIB_PATH}/lib${PROJECT_NAME}.so\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/lib\")\nset_target_properties(${PROJECT_NAME} PROPERTIES\n INTERFACE_LINK_LIBRARIES \"$/share/${PROJECT_NAME}/gxf/lib/lib${PROJECT_NAME}.so\"\n)\n\n# Install headers\nif(EXISTS \"${CMAKE_CURRENT_SOURCE_DIR}/gxf\")\n install(DIRECTORY \"${CMAKE_CURRENT_SOURCE_DIR}/gxf/\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/include\")\n set_target_properties(${PROJECT_NAME} PROPERTIES\n INTERFACE_INCLUDE_DIRECTORIES \"$/share/${PROJECT_NAME}/gxf/include\")\nendif()\n\ninstall(TARGETS ${PROJECT_NAME}\n EXPORT export_${PROJECT_NAME}\n LIBRARY DESTINATION lib\n ARCHIVE DESTINATION lib\n RUNTIME DESTINATION bin)\nament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)\n\n\n# Embed versioning information into installed files\nament_index_get_resource(ISAAC_ROS_COMMON_CMAKE_PATH isaac_ros_common_cmake_path isaac_ros_common)\ninclude(\"${ISAAC_ROS_COMMON_CMAKE_PATH}/isaac_ros_common-version-info.cmake\")\ngenerate_version_info(${PROJECT_NAME})\n\nament_auto_package(INSTALL_TO_SHARE)\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_cuda/package.xml", "content": "\n\n\n\n\n\n gxf_isaac_cuda\n 4.4.0\n GXF extension for Cuda related components in GXF Core.\n\n Isaac ROS Maintainers\n Apache-2.0\n https://developer.nvidia.com/isaac-ros-gems/\n CY Chen\n\n ament_cmake_auto\n\n isaac_ros_common\n isaac_ros_gxf\n\n ament_lint_auto\n ament_lint_common\n\n \n ament_cmake\n \n\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_flatscan_localization/CMakeLists.txt", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\ncmake_minimum_required(VERSION 3.22.1)\nproject(gxf_isaac_flatscan_localization LANGUAGES C CXX)\n\nif(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n add_compile_options(-Wall -Wextra -Wpedantic)\nendif()\n\nfind_package(ament_cmake_auto REQUIRED)\nament_auto_find_build_dependencies()\n\n# Determine the architecture\nif(CMAKE_SYSTEM_PROCESSOR MATCHES \"aarch64\")\n if(CMAKE_DEVICE STREQUAL \"sbsa\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_aarch64_cuda_13_0\")\n elseif(CMAKE_DEVICE STREQUAL \"arm64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_jetpack70\")\n else()\n message(FATAL_ERROR \"Device is not supported.\")\n endif()\nelseif(CMAKE_SYSTEM_PROCESSOR MATCHES \"x86_64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_x86_64_cuda_13_0\")\nelse()\n message(FATAL_ERROR \"Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}\")\nendif()\n\n# Add an interface target to export dependencies\nadd_library(${PROJECT_NAME} INTERFACE)\n\n# Install shared library\ninstall(FILES \"${GXF_EXT_LIB_PATH}/lib${PROJECT_NAME}.so\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/lib\")\nset_property(TARGET ${PROJECT_NAME} PROPERTY\n INTERFACE_LINK_LIBRARIES\n \"$/share/${PROJECT_NAME}/gxf/lib/lib${PROJECT_NAME}.so\"\n)\n\n# Install headers\nif(EXISTS \"${CMAKE_CURRENT_SOURCE_DIR}/gxf\")\n install(DIRECTORY \"${CMAKE_CURRENT_SOURCE_DIR}/gxf/\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/include\")\n set_target_properties(${PROJECT_NAME} PROPERTIES\n INTERFACE_INCLUDE_DIRECTORIES\n \"$/share/${PROJECT_NAME}/gxf/include\")\nendif()\n\ninstall(TARGETS ${PROJECT_NAME}\n EXPORT export_${PROJECT_NAME}\n LIBRARY DESTINATION lib\n ARCHIVE DESTINATION lib\n RUNTIME DESTINATION bin)\nament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)\n\n\n# Embed versioning information into installed files\nament_index_get_resource(ISAAC_ROS_COMMON_CMAKE_PATH isaac_ros_common_cmake_path isaac_ros_common)\ninclude(\"${ISAAC_ROS_COMMON_CMAKE_PATH}/isaac_ros_common-version-info.cmake\")\ngenerate_version_info(${PROJECT_NAME})\n\nament_auto_package(INSTALL_TO_SHARE)" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_flatscan_localization/package.xml", "content": "\n\n\n\n\n\n gxf_isaac_flatscan_localization\n 4.4.0\n Extension containing flatscan localization related components.\n\n Isaac ROS Maintainers\n Apache-2.0\n https://developer.nvidia.com/isaac-ros-gems/\n CY Chen\n\n ament_cmake_auto\n\n isaac_ros_common\n isaac_ros_gxf\n\n ament_lint_auto\n ament_lint_common\n\n \n ament_cmake\n \n\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/CMakeLists.txt", "content": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n#\n# SPDX-License-Identifier: Apache-2.0\n\ncmake_minimum_required(VERSION 3.22.1)\nproject(gxf_isaac_gems LANGUAGES C CXX)\n\nif(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n add_compile_options(-Wall -Wextra -Wpedantic)\nendif()\n\nfind_package(ament_cmake_auto REQUIRED)\nament_auto_find_build_dependencies()\n\nfind_package(Eigen3 3.3 REQUIRED NO_MODULE)\n\n# Determine the architecture\nif(CMAKE_SYSTEM_PROCESSOR MATCHES \"aarch64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_jetpack70\")\nelseif(CMAKE_SYSTEM_PROCESSOR MATCHES \"x86_64\")\n set(GXF_EXT_LIB_PATH \"${CMAKE_CURRENT_SOURCE_DIR}/lib/gxf_x86_64_cuda_13_0\")\nelse()\n message(FATAL_ERROR \"Unsupported architecture: ${CMAKE_SYSTEM_PROCESSOR}\")\nendif()\n\n# Add an interface target to export dependencies\nadd_library(${PROJECT_NAME} INTERFACE)\n\n# Install headers\nif(EXISTS \"${CMAKE_CURRENT_SOURCE_DIR}/gxf\")\n install(DIRECTORY \"${CMAKE_CURRENT_SOURCE_DIR}/gxf/\"\n DESTINATION \"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/gxf/include\")\n set_property(TARGET ${PROJECT_NAME} PROPERTY\n INTERFACE_INCLUDE_DIRECTORIES\n \"${EIGEN3_INCLUDE_DIR}\"\n \"$/share/${PROJECT_NAME}/gxf/include\"\n )\nendif()\n\ninstall(TARGETS ${PROJECT_NAME}\n EXPORT export_${PROJECT_NAME}\n LIBRARY DESTINATION lib\n ARCHIVE DESTINATION lib\n RUNTIME DESTINATION bin)\nament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)\n\n\n# Embed versioning information into installed files\nament_index_get_resource(ISAAC_ROS_COMMON_CMAKE_PATH isaac_ros_common_cmake_path isaac_ros_common)\ninclude(\"${ISAAC_ROS_COMMON_CMAKE_PATH}/isaac_ros_common-version-info.cmake\")\ngenerate_version_info(${PROJECT_NAME})\n\nament_auto_package(INSTALL_TO_SHARE)" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/algorithm/string_utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace nvidia {\nnamespace isaac {\n\n// Checks wether a string starts with a certain string\ninline bool StartsWith(const std::string& str, const std::string& prefix) {\n return str.size() >= prefix.size()\n && str.compare(0, prefix.size(), prefix) == 0;\n}\n\n// Checks wether a string ends with a certain string\ninline bool EndsWith(const std::string& str, const std::string& suffix) {\n return str.size() >= suffix.size()\n && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;\n}\n\n// Creates a random alpha-numeric string\ntemplate \nstd::string RandomAlphaNumeric(size_t length, URBG&& rng) {\n // All alpha numeric characters\n constexpr char kAlphaNumeric[] =\n \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n \"abcdefghijklmnopqrstuvwxyz\"\n \"0123456789\";\n std::uniform_int_distribution random_index(0, sizeof(kAlphaNumeric) - 1);\n std::string result(length, 0);\n std::generate_n(result.begin(), length, [&]() { return kAlphaNumeric[random_index(rng)]; });\n return result;\n}\n\n// Splits a string by deliminator character\ninline std::vector SplitString(const std::string& str, const char delim) {\n std::vector result;\n std::stringstream ss(str);\n std::string item;\n while (!std::getline(ss, item, delim).fail()) {\n result.push_back(item);\n }\n return result;\n}\n\n// Converts a string to lower-case characters\ninline std::string ToLowerCase(std::string data) {\n std::transform(data.begin(), data.end(), data.begin(), ::tolower);\n return data;\n}\n\n// Trims the spaces at the beginning and end of string\ninline std::string TrimString(std::string s) {\n s.erase(s.begin(), find_if(s.begin(), s.end(), [](int ch) { return !std::isspace(ch); }));\n s.erase(find_if(s.rbegin(), s.rend(), [](int ch) { return !std::isspace(ch); }).base(), s.end());\n return s;\n}\n\n// Returns a new string containing the last count characters of a string\ninline std::string TakeLast(const std::string& str, size_t count) {\n if (str.length() <= count) {\n return str;\n } else {\n if (count < 2) {\n return str.substr(str.length() - count, count);\n } else {\n return \"..\" + str.substr(str.length() - count + 2, count - 2);\n }\n }\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/common/composite_schema_uid.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\nnamespace nvidia {\nnamespace isaac {\n\n// Composite schema identification for the data in a message.\nstruct CompositeSchemaUid {\n // Unique identifier of the composite schema which is used to represent the data\n uint64_t uid;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/common/pose_frame_uid.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\nnamespace nvidia {\nnamespace isaac {\n\n// Spatial information for the data in a message.\nstruct PoseFrameUid {\n // Unique identifier of the pose tree frame to which this data is attached.\n uint64_t uid;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/composite/composite_from_tensor.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/composite/composite_view.hpp\"\n#include \"gems/composite/schema_tensor_archive.hpp\"\n#include \"gems/core/tensor/tensor.hpp\"\n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\nnamespace from_tensor_details {\n\n// Check to see if we actually derive from a composite view\nstd::false_type composite_view_match(const void*);\ntemplate \nstd::true_type composite_view_match(const CompositeContainerConstPointer*);\ntemplate \nstd::true_type composite_view_match(const CompositeContainerPointer*);\n\n// Check to see if we actually derive from a composite view\nstd::false_type composite_data_match(const void*);\ntemplate \nstd::true_type composite_data_match(const CompositeContainerArray*);\ntemplate \nstd::true_type composite_data_match(const CompositeContainerEigen*);\n\n// Define helper types.\ntemplate \nusing is_composite_view = decltype(composite_view_match(std::declval()));\ntemplate \nusing is_composite_data = decltype(composite_data_match(std::declval()));\n\n} // namespace from_tensor_details\n\n// Constructs CompositeConstView from TensorConstView\ntemplate \ngxf::Expected CompositeFromTensor(\n ::nvidia::isaac::CpuTensorConstView tensor) {\n static_assert(from_tensor_details::is_composite_view::value, \"Type needs to be a composite\");\n if (tensor.dimensions()[0] != T::kDimension) {\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n T derived;\n derived.pointer = tensor.element_wise_begin();\n return derived;\n}\n\n// Constructs CompositeView or CompositeConstView from TensorView\ntemplate \ngxf::Expected CompositeFromTensor(\n ::nvidia::isaac::CpuTensorView tensor) {\n static_assert(from_tensor_details::is_composite_view::value, \"Type needs to be a composite\");\n if (tensor.dimensions()[0] != T::kDimension) {\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n T derived;\n derived.pointer = tensor.element_wise_begin();\n return derived;\n}\n\n// Constructs CompositeView or CompositeConstView from Tensor\ntemplate \ngxf::Expected CompositeFromTensor(::nvidia::isaac::CpuTensor& tensor) {\n return CompositeFromTensor(tensor.view());\n}\n\n// Constructs CompositeArray or CompositeEigen from TensorConstView and schemas\ntemplate \ngxf::Expected CompositeFromTensor(\n ::nvidia::isaac::CpuTensorConstView tensor,\n const composite::Schema& tensor_schema,\n const composite::Schema& composite_schema) {\n static_assert(from_tensor_details::is_composite_data::value, \"Type must be a composite data \"\n \"container, since we cannot guarantee parameter order\");\n const auto maybe_index_map = CompositeIndexMap::Create(composite_schema, tensor_schema);\n if (!maybe_index_map) {\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n\n T derived;\n FromSchemaTensor(tensor, *maybe_index_map, derived);\n return derived;\n}\n\n// Constructs CompositeArray or CompositeEigen from Tensor and schemas\ntemplate \ngxf::Expected CompositeFromTensor(::nvidia::isaac::CpuTensor& tensor,\n const composite::Schema& tensor_schema,\n const composite::Schema& composite_schema) {\n return CompositeFromTensor(tensor.const_view(), tensor_schema, composite_schema);\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/composite/composite_view.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Forward declare for operator=\ntemplate \nstruct CompositeContainerConstPointer;\ntemplate \nstruct CompositeContainerPointer;\ntemplate \nstruct CompositeContainerArray;\ntemplate \nstruct CompositeContainerEigen;\n\n// A base class for an immutable composite view which uses a const pointer to access data.\ntemplate \nstruct CompositeContainerConstPointer {\n CompositeContainerConstPointer() : pointer(nullptr) {}\n CompositeContainerConstPointer(const K* p) : pointer(p) {}\n\n static_assert(std::is_arithmetic::value, \"Composite only supports arithmetic types\");\n\n using scalar_t = K;\n using Scalar = K;\n static constexpr int32_t kDimension = N;\n\n constexpr int32_t size() const { return N; }\n\n K operator[](int32_t i) const { return pointer[i]; }\n\n const K* pointer;\n};\n\n// Accesses an element in a composite\ntemplate \nK get(const CompositeContainerConstPointer& state) {\n static_assert(0 <= I && I < N, \"Index out of bounds\");\n return state.pointer[I];\n}\n\n// A base class for a mutable composite view which uses a pointer to access data.\ntemplate \nstruct CompositeContainerPointer {\n CompositeContainerPointer() : pointer(nullptr) {}\n CompositeContainerPointer(K* p) : pointer(p) {}\n\n static_assert(std::is_arithmetic::value, \"Composite only supports arithmetic types\");\n\n using scalar_t = K;\n using Scalar = K;\n static constexpr int32_t kDimension = N;\n\n constexpr int32_t size() const { return N; }\n\n K operator[](int32_t i) const { return pointer[i]; }\n K& operator[](int32_t i) { return pointer[i]; }\n\n CompositeContainerPointer& operator=(const CompositeContainerConstPointer& other) {\n for (int32_t i = 0; i < size(); ++i) {\n pointer[i] = other[i];\n }\n return *this;\n }\n CompositeContainerPointer& operator=(const CompositeContainerArray& other) {\n for (int32_t i = 0; i < size(); ++i) {\n pointer[i] = other[i];\n }\n return *this;\n }\n CompositeContainerPointer& operator=(const CompositeContainerEigen& other) {\n for (int32_t i = 0; i < size(); ++i) {\n pointer[i] = other[i];\n }\n return *this;\n }\n\n K* pointer;\n};\n\n// Accesses an element in a composite\ntemplate \nK get(const CompositeContainerPointer& state) {\n static_assert(0 <= I && I < N, \"Index out of bounds\");\n return state.pointer[I];\n}\n\n// Accesses an element in a composite\ntemplate \nK& get(CompositeContainerPointer& state) {\n static_assert(0 <= I && I < N, \"Index out of bounds\");\n return state.pointer[I];\n}\n\n// A base class for a composite which uses std::array to store data.\ntemplate \nstruct CompositeContainerArray {\n static_assert(std::is_arithmetic::value, \"Composite only supports arithmetic types\");\n\n using scalar_t = K;\n using Scalar = K;\n static constexpr int32_t kDimension = N;\n\n constexpr int32_t size() const { return N; }\n\n K operator[](int32_t i) const { return data[i]; }\n K& operator[](int32_t i) { return data[i]; }\n\n CompositeContainerArray& operator=(const CompositeContainerConstPointer& other) {\n for (int32_t i = 0; i < size(); ++i) {\n data[i] = other[i];\n }\n return *this;\n }\n CompositeContainerArray& operator=(const CompositeContainerPointer& other) {\n for (int32_t i = 0; i < size(); ++i) {\n data[i] = other[i];\n }\n return *this;\n }\n\n std::array data;\n};\n\n// A base class for a composite which uses ::nvidia::isaac::Vector to store data.\ntemplate \nstruct CompositeContainerEigen {\n static_assert(std::is_arithmetic::value, \"Composite only supports arithmetic types\");\n\n using scalar_t = K;\n using Scalar = K;\n static constexpr int32_t kDimension = N;\n\n constexpr int32_t size() const { return N; }\n\n K operator[](int32_t i) const { return elements[i]; }\n K& operator[](int32_t i) { return elements[i]; }\n\n CompositeContainerEigen& operator=(const CompositeContainerConstPointer& other) {\n for (int32_t i = 0; i < size(); ++i) {\n elements[i] = other[i];\n }\n return *this;\n }\n CompositeContainerEigen& operator=(const CompositeContainerPointer& other) {\n for (int32_t i = 0; i < size(); ++i) {\n elements[i] = other[i];\n }\n return *this;\n }\n\n ::nvidia::isaac::Vector elements;\n};\n\n// Accesses an element in a composite\ntemplate \nK get(const CompositeContainerArray& state) {\n return std::get(state.data);\n}\n\n// Accesses an element in a composite\ntemplate \nK& get(CompositeContainerArray& state) {\n return std::get(state.data);\n}\n\n// Accesses an element in a composite\ntemplate \nK get(const CompositeContainerEigen& state) {\n return state.elements[I];\n}\n\n// Accesses an element in a composite\ntemplate \nK& get(CompositeContainerEigen& state) {\n return state.elements[I];\n}\n\n// An immutable composite view\ntemplate typename ImmutableInterface>\nusing CompositeConstView = ImmutableInterface>;\n\n// A mutable composite view\ntemplate typename MutableInterface>\nusing CompositeView = MutableInterface>;\n\n// A composite which owns its data\ntemplate typename MutableInterface>\nusing Composite = MutableInterface>;\n\n// A composite which owns its data as an Eigen Vector\ntemplate typename MutableInterface>\nusing CompositeEigen = MutableInterface>;\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/composite/measure.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\nnamespace nvidia {\nnamespace isaac {\nnamespace composite {\n\n// Possible measure for an entity in Composite Message\nenum class Measure {\n kNone, // Unknown\n kTime, // Second\n kMass, // Kilogram\n kPosition, // Meter\n kSpeed, // Meter per second\n kAcceleration, // Meter per squared second\n kRotation, // Rotation of 2d or 3d\n kAngularSpeed, // Radian per second\n kAngularAcceleration, // Radian per squared second\n kNormal, // A normal\n kColor, // A color\n kCurvature, // Radian per meter\n kCurvatureDerivative, // Radian per squared meter\n};\n\n} // namespace composite\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/composite/quantity.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/composite/measure.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace composite {\n\n// A quantity describes meta data for values stored in a composite.\nstruct Quantity {\n // Helper function to create a scalar quantity\n static Quantity Scalar(std::string entity, Measure measure) {\n return Quantity{std::move(entity), measure, ::nvidia::isaac::VectorXi::Constant(1, 1)};\n }\n\n // Helper function to create a vector quantity\n static Quantity Vector(std::string entity, Measure measure, int dimension) {\n return Quantity{std::move(entity), measure, ::nvidia::isaac::VectorXi::Constant(1, dimension)};\n }\n\n // Equality operator\n bool operator==(const Quantity& other) const {\n return measure == other.measure && entity == other.entity && dimensions == other.dimensions;\n }\n\n // Total number of elements\n int getElementCount() const { return dimensions.prod(); }\n\n // The name of the entity for which the values was measured. Multiple quantities can be\n // measured per entity.\n std::string entity;\n // The measure, e.g. unit or type, of the value.\n Measure measure;\n // The dimensions of the value. Values can be multi-dimensional but most are scalars or vectors.\n ::nvidia::isaac::VectorXi dimensions;\n};\n\n// Exact comparison of quantities\nstruct QuantityEquality {\n bool operator()(const Quantity& lhs, const Quantity& rhs) const { return lhs == rhs; }\n};\n\n// Hash function for quantities using combination of hashes on elements\nstruct QuantityHash {\n std::size_t operator()(const Quantity& value) const {\n return std::hash{}.operator()(value.entity) ^\n std::hash{}.operator()(static_cast(value.measure)) ^\n std::hash{}.operator()(static_cast(value.dimensions.size()));\n }\n};\n\n} // namespace composite\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/composite/schema.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \"gems/composite/quantity.hpp\"\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/optional.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace composite {\n\n// A schema contains information about the quantities which are stored in the composite\nclass Schema {\n public:\n // Constructs schema from given quanties\n static std::optional Create(std::vector&& quantities, std::string hash = \"\");\n // Constructs schema from scalar quantities of identical measure\n static std::optional Create(\n const std::vector& entities, const Measure measure);\n\n // Similar to `Create` but will Assert if schema is invalid\n Schema(std::vector&& quantities, std::string hash = \"\");\n // Similar to `Create` but will Assert if schema is invalid\n Schema(const std::vector& entities, const Measure measure);\n\n // Empty schema\n Schema() = default;\n\n // Equality operator\n bool operator==(const Schema& other) const {\n return element_count_ == other.element_count_ && hash_ == other.hash_ &&\n quantities_ == other.quantities_;\n }\n\n // The hash of the schame\n const std::string& getHash() const { return hash_; }\n\n // Returns a list of all quantities\n const std::vector& getQuantities() const { return quantities_; }\n\n // Total number of values required to store the schema\n int getElementCount() const { return element_count_; }\n\n // Gets the starting index of a quantity in the list ofvalues. Returns nullopt if quantity is\n // not in the schema.\n std::optional findQuantityValueIndex(const Quantity& quantity) const;\n\n private:\n // Updates `element_count_`, `values_offset_` and `index_` variables based on quantities.\n bool createIndex();\n\n // The hash of the currently used schema\n std::string hash_;\n\n // All quantities which are part of this schema\n std::vector quantities_;\n\n // Total number of elements in the schema\n int element_count_ = 0;\n\n // Indies of first quantity element in the values vector\n std::unordered_map index_;\n};\n\n} // namespace composite\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/composite/schema_tensor_archive.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"common/expected.hpp\"\n#include \"gems/composite/schema.hpp\"\n#include \"gems/core/tensor/tensor.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// An index map which can be used to map indices from one composite to another.\nclass CompositeIndexMap {\n public:\n // Error codes used by this data type\n enum struct Error {\n kQuantityNotFound, // A quantity from the target schema was not found in the source schema.\n };\n\n // Computes an index map which can be used to associate elements in the target schema with\n // elements in the source schema. Will fail in case the mapping is not possible.\nstatic Expected Create(const composite::Schema& source,\n const composite::Schema& target);\n\n // Map a target index to the corresponding source index (see ComputeCompositeIndexMap)\n int32_t operator()(int32_t target) const { return indices_[target]; }\n\n private:\n // Private constructor to force initialization through static builder for RAII.\n CompositeIndexMap(int size) : indices_(size) {}\n\n // Stores the source index for each target index.\n // FIXME Use a stack allocated, bounded data type once available.\n std::vector indices_;\n};\n\n// Helper type to encode a composite into a tensor\ntemplate \nstruct TensorArchiveEncoder {\n // Writes a value into the tensor at the given index.\n void operator()(int32_t index, K value) {\n composite_tensor(index) = value;\n }\n\n // The encoder writes data to this tensor.\n ::nvidia::isaac::CpuTensorView1 composite_tensor;\n};\n\n// Helper type to decode a composite from a tensor with the help of an index map\ntemplate \nstruct TensorArchiveDecoder {\n // Reads a value from the tensor using an index from the *target* schema. The index map is used\n // to map target schema indices to indices used to access the tensor.\n void operator()(int32_t index, K& value) {\n value = composite_tensor(composite_index_map(index));\n }\n\n // The decoder reads data from this tensor.\n ::nvidia::isaac::CpuTensorConstView1 composite_tensor;\n // An index map which is used to map indices given to `operator()` to the correct location in\n // the tensor.\n CompositeIndexMap composite_index_map;\n};\n\n// Reads a composite state from a tensor\ntemplate \nvoid FromSchemaTensor(\n ::nvidia::isaac::CpuTensorConstView1 composite_tensor,\n const CompositeIndexMap& composite_index_map, State& state) {\n TensorArchiveDecoder decoder{composite_tensor, composite_index_map};\n for (int32_t i = 0; i < state.size(); i++) {\n decoder(i, state[i]);\n }\n}\n\n// Writes a composite state to a tensor\ntemplate \nvoid ToSchemaTensor(const State& state,\n ::nvidia::isaac::CpuTensorView1 composite_tensor) {\n TensorArchiveEncoder encoder{composite_tensor};\n for (int32_t i = 0; i < state.size(); i++) {\n encoder(i, state[i]);\n }\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/coms/socket.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"gems/core/logger.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\nclass Socket {\n public:\n // Creates a UDP receiving socket\n // Remote address corresponds to the sending socket. Port will be used for remote and local port\n static Socket* CreateRxUDPSocket(const std::string& remote_address, uint16_t port) {\n Socket* s = new Socket(remote_address, port, SOCK_DGRAM);\n memset(&s->local_address_, 0, sizeof(s->local_address_));\n s->local_address_.sin_port = htons(port);\n s->local_address_.sin_family = AF_INET;\n s->local_address_.sin_addr.s_addr = htonl(INADDR_ANY);\n return s;\n }\n\n // Creates a TCP receiving socket\n static Socket* CreateRxTCPSocket(const std::string& source_address, uint16_t source_port) {\n return new Socket(source_address, source_port, SOCK_STREAM);\n }\n\n // Try to start a socket or fails and return -1\n int32_t startSocket() {\n int32_t res = 0;\n\n // TODO Assert\n if (type_ == SOCK_STREAM) {\n res = connect(sockfd_, (struct sockaddr *)&emitter_address_,\n sizeof(emitter_address_));\n LOG_WARNING(\"Never tested\");\n // Set reading options\n read_flags_ = MSG_PEEK | MSG_WAITALL;\n } else if (type_ == SOCK_DGRAM) {\n uint32_t reuse = 1;\n // Set Reuse Option\n struct timeval tv;\n tv.tv_sec = 1;\n tv.tv_usec = 0;\n res |= setsockopt(sockfd_, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));\n res |= setsockopt(sockfd_, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(uint32_t));\n if (res < 0) {\n LOG_ERROR(\"Cannot set Socket options\");\n }\n if (bind(sockfd_, (struct sockaddr *)&local_address_, sizeof(local_address_)) == -1) {\n LOG_ERROR(\"Cannot bind!\");\n return -1;\n }\n read_flags_ = 0;\n }\n is_running_ = true;\n return res;\n }\n\n // Reads a packet\n size_t readPacket(char* data, size_t size) {\n if (!sockfd_) {\n LOG_ERROR(\"Socket is invalid, reopen the connection!\");\n return -1;\n }\n socklen_t slen = sizeof(emitter_address_);\n int32_t recvlen = recvfrom(sockfd_, data, size, 0,\n (struct sockaddr *)&emitter_address_, &slen);\n return recvlen;\n }\n\n // Reads a packet from\n size_t writePacket(const void* data, size_t size) {\n if (!sockfd_) {\n LOG_ERROR(\"Socket is invalid, reopen the connection!\");\n return -1;\n }\n socklen_t slen = sizeof(emitter_address_);\n int32_t recvlen = sendto(sockfd_, data, size, 0,\n (struct sockaddr *)&emitter_address_, slen);\n return recvlen;\n }\n\n // Closes socket\n void closeSocket() {\n if (sockfd_) {\n close(sockfd_);\n }\n is_running_ = false;\n }\n\n bool isRunning() {\n return is_running_;\n }\n\n // Identify the (externally exposed) IPv4 address corresponding to this communication socket.\n uint32_t getIpv4() const {\n uint32_t local_ipv4_address(0);\n\n // For each connected IPv4 network interface address, if the emitter address meets masking\n // requirement, we found our local IPv4. Don't bother checking if the socket is not running.\n struct ifaddrs* network_interface_addresses = nullptr;\n if (getifaddrs(&network_interface_addresses) != -1) {\n struct ifaddrs* network_interface_addresses_iterator = network_interface_addresses;\n while (network_interface_addresses_iterator != nullptr) {\n // Validate the socket family is indeed IPv4.\n if ((network_interface_addresses_iterator->ifa_addr != nullptr) &&\n (network_interface_addresses_iterator->ifa_addr->sa_family == AF_INET)) {\n // Validate the socket is actually connected.\n struct sockaddr_in* local_socket_address =\n (struct sockaddr_in*)network_interface_addresses_iterator->ifa_addr;\n if (local_socket_address->sin_addr.s_addr != htonl(INADDR_ANY)) {\n // Validate the network masking requirements meets our emitter address.\n struct sockaddr_in* ifu_netmask =\n (struct sockaddr_in*)network_interface_addresses_iterator->ifa_netmask;\n if ((local_socket_address->sin_addr.s_addr & ifu_netmask->sin_addr.s_addr) ==\n (emitter_address_.sin_addr.s_addr & ifu_netmask->sin_addr.s_addr)) {\n local_ipv4_address = local_socket_address->sin_addr.s_addr;\n break;\n }\n }\n }\n network_interface_addresses_iterator = network_interface_addresses_iterator->ifa_next;\n }\n\n if (network_interface_addresses) {\n freeifaddrs(network_interface_addresses);\n }\n }\n\n return local_ipv4_address;\n }\n\n int32_t getFileDescriptor() const {\n return sockfd_;\n }\n\n private:\n int32_t sockfd_;\n struct sockaddr_in local_address_;\n struct sockaddr_in emitter_address_;\n\n int32_t read_flags_;\n int32_t type_;\n bool is_running_;\n\n Socket(const std::string& remote_address, uint16_t remote_port, uint16_t type,\n const std::string& interface = \"\") {\n // Prepares for incoming data\n memset(&emitter_address_, 0, sizeof(emitter_address_));\n emitter_address_.sin_port = htons(remote_port);\n emitter_address_.sin_family = AF_INET;\n emitter_address_.sin_addr.s_addr = inet_addr(remote_address.c_str());\n type_ = type;\n is_running_ = false;\n\n // Creates the socket\n sockfd_ = socket(AF_INET, type, 0);\n\n if (!interface.empty()) {\n struct ifreq if_bind;\n strncpy(if_bind.ifr_name, interface.c_str(), IFNAMSIZ);\n const int error = setsockopt(sockfd_, SOL_SOCKET, SO_BINDTODEVICE,\n reinterpret_cast(&if_bind), sizeof(if_bind));\n if (error < 0) {\n LOG_ERROR(\"Failed to specify interface %s\", interface.c_str());\n }\n }\n }\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/control_types/differential_drive.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/composite/composite_view.hpp\"\n#include \"gems/composite/schema.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Describes the full 2D pose and kinematic state of a Differential base\nstruct DifferentialBaseEgoMotionIndices {\n enum {\n // Cartesian position X (m)\n kPositionX,\n // Cartesian position Y (m)\n kPositionY,\n // In-plane rotation angle (radian)\n kHeading,\n // Linear (longitudinal) speed (m/s)\n kLinearSpeed,\n // Rotation speed (radian/s)\n kAngularSpeed,\n // Linear (longitudinal) acceleration (m/s^2)\n kLinearAcceleration,\n // Angular (rotaion) acceleration (radians/s^2)\n kAngularAcceleration,\n kSize\n };\n};\n\ninline composite::Schema DifferentialBaseEgoMotionCompositeSchema() {\n return composite::Schema({\n composite::Quantity::Vector(\"position\", composite::Measure::kPosition, 2),\n composite::Quantity::Scalar(\"heading\", composite::Measure::kRotation),\n composite::Quantity::Scalar(\"linear_speed\", composite::Measure::kSpeed),\n composite::Quantity::Scalar(\"angular_speed\", composite::Measure::kAngularSpeed),\n composite::Quantity::Scalar(\"linear_acceleration\", composite::Measure::kAcceleration),\n composite::Quantity::Scalar(\"angular_acceleration\", composite::Measure::kAngularAcceleration),\n });\n}\n\ntemplate \nstruct DifferentialBaseEgoMotionImmutableInterface : public Base {\n using Base::operator=;\n using Vector2ConstMap = Eigen::Map<\n const ::nvidia::isaac::Vector2, 0,\n Eigen::InnerStride>;\n K position_x() const { return get(*this); }\n K position_y() const { return get(*this); }\n K heading() const { return get(*this); }\n K linear_speed() const { return get(*this); }\n K angular_speed() const { return get(*this); }\n K linear_acceleration() const {\n return get(*this); }\n K angular_acceleration() const {\n return get(*this); }\n\n Vector2ConstMap position() const {\n return Vector2ConstMap(this->pointer + DifferentialBaseEgoMotionIndices::kPositionX);\n }\n};\n\ntemplate \nstruct DifferentialBaseEgoMotionMutableInterface :\n public DifferentialBaseEgoMotionImmutableInterface {\n using DifferentialBaseEgoMotionImmutableInterface::operator=;\n using Vector2Map = Eigen::Map<::nvidia::isaac::Vector2, 0,\n Eigen::InnerStride>;\n K position_x() const { return get(*this); }\n K position_y() const { return get(*this); }\n K heading() const { return get(*this); }\n K angular_speed() const { return get(*this); }\n K linear_speed() const { return get(*this); }\n K angular_acceleration() const {\n return get(*this); }\n K linear_acceleration() const {\n return get(*this); }\n\n K& position_x() { return get(*this); }\n K& position_y() { return get(*this); }\n K& heading() { return get(*this); }\n K& angular_speed() { return get(*this); }\n K& linear_speed() { return get(*this); }\n K& angular_acceleration() {\n return get(*this); }\n K& linear_acceleration() {\n return get(*this); }\n\n Vector2Map position() { return Vector2Map(&position_x()); }\n};\n\ntemplate \nusing DifferentialBaseEgoMotionConstView = CompositeConstView;\n\ntemplate \nusing DifferentialBaseEgoMotionView = CompositeView;\n\ntemplate \nusing DifferentialBaseEgoMotion = Composite;\n\ntemplate \nusing DifferentialBaseEgoMotionEigen =\n CompositeEigen;\n\n// Describes the command type for a Differential base, ie. output of a controller and intput to the\n// hardware driver\nstruct DifferentialBaseCommandIndices {\n enum {\n // Linear (longitudinal) speed (m/s)\n kLinearSpeed,\n // Rotation speed (radian/s)\n kAngularSpeed,\n kSize\n };\n};\n\ninline composite::Schema DifferentialBaseCommandCompositeSchema() {\n return composite::Schema({\n composite::Quantity::Scalar(\"linear_speed\", composite::Measure::kSpeed),\n composite::Quantity::Scalar(\"angular_speed\", composite::Measure::kAngularSpeed),\n });\n}\n\ntemplate \nstruct DifferentialBaseCommandImmutableInterface : public Base {\n using Base::operator=;\n\n K linear_speed() const { return get(*this); }\n K angular_speed() const { return get(*this); }\n};\n\ntemplate \nstruct DifferentialBaseCommandMutableInterface :\n public DifferentialBaseCommandImmutableInterface {\n using DifferentialBaseCommandImmutableInterface::operator=;\n\n K linear_speed() const { return get(*this); }\n K angular_speed() const { return get(*this); }\n\n K& linear_speed() { return get(*this); }\n K& angular_speed() { return get(*this); }\n};\n\ntemplate \nusing DifferentialBaseCommandConstView =\n CompositeConstView;\n\ntemplate \nusing DifferentialBaseCommandView =\n CompositeView;\n\ntemplate \nusing DifferentialBaseCommand = Composite;\n\n// Describes the kinematic state for an Differential base, for example input to base odometry\nstruct DifferentialBaseStateIndices {\n enum {\n // Linear (longitudinal) speed (m/s)\n kLinearSpeed,\n // Rotation speed (radian/s)\n kAngularSpeed,\n // Linear (longitudinal) acceleration (m/s^2)\n kLinearAcceleration,\n // Angular (rotational) acceleration (radians/s^2)\n kAngularAcceleration,\n kSize\n };\n};\n\ninline composite::Schema DifferentialBaseStateCompositeSchema() {\n return composite::Schema({\n composite::Quantity::Scalar(\"linear_speed\", composite::Measure::kSpeed),\n composite::Quantity::Scalar(\"angular_speed\", composite::Measure::kRotation),\n composite::Quantity::Scalar(\"linear_acceleration\", composite::Measure::kAcceleration),\n composite::Quantity::Scalar(\"angular_acceleration\", composite::Measure::kRotation)\n });\n}\n\ntemplate \nstruct DifferentialBaseStateImmutableInterface : public Base {\n using Base::operator=;\n\n K linear_speed() const { return get(*this); }\n K angular_speed() const { return get(*this); }\n K linear_acceleration() const {\n return get(*this); }\n K angular_acceleration() const {\n return get(*this);\n }\n};\n\ntemplate \nstruct DifferentialBaseStateMutableInterface\n : public DifferentialBaseStateImmutableInterface {\n using DifferentialBaseStateImmutableInterface::operator=;\n\n K linear_speed() const { return get(*this); }\n K angular_speed() const { return get(*this); }\n K linear_acceleration() const {\n return get(*this); }\n K angular_acceleration() const {\n return get(*this); }\n\n K& linear_speed() { return get(*this); }\n K& angular_speed() {\n return get(*this); }\n K& linear_acceleration() {\n return get(*this); }\n K& angular_acceleration() {\n return get(*this);\n }\n};\n\ntemplate \nusing DifferentialBaseStateConstView =\n CompositeConstView;\n\ntemplate \nusing DifferentialBaseStateView =\n CompositeView;\n\ntemplate \nusing DifferentialBaseState =\n Composite;\n\ntemplate \nusing DifferentialBaseStateEigen =\n CompositeEigen;\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/allocator/allocator_base.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2019-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/byte.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Base class for allocators which allocate and deallocate blocks of memory.\nclass AllocatorBase {\n public:\n // Type for a raw pointer to a block of memory\n using pointer_t = byte*;\n\n virtual ~AllocatorBase() = default;\n\n // Allocates memory for at least N instances of the given type\n template \n T* allocate(size_t count) {\n return reinterpret_cast(allocateBytes(sizeof(T) * count));\n }\n\n // Deallocates a block of memory previously allocated with `allocate`. Need to be passed the same\n // instance count used during the call to `allocate`.\n template \n void deallocate(T* pointer, size_t count) {\n deallocateBytes(reinterpret_cast(pointer), sizeof(T) * count);\n }\n\n // Allocates memory for at least the given number of bytes\n virtual pointer_t allocateBytes(size_t size) = 0;\n\n // Deallocates a block of memory previously allocated with `allocate`. Need to be passed the same\n // byte count used during the call to `allocate`.\n virtual void deallocateBytes(pointer_t pointer, size_t size) = 0;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/allocator/allocators.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2019-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/allocator/allocator_base.hpp\"\n#include \"gems/core/byte.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Provides a globally available allocator to allocate CPU memory.\nstruct CpuAllocator {\n static byte* Allocate(size_t size);\n static void Deallocate(byte* pointer, size_t size);\n};\n\n// Gets the currently used allocator for CPU memory allocation.\nAllocatorBase* GetCpuAllocator();\n\n// Provides a globally available allocator to allocate CUDA memory.\nstruct CudaAllocator {\n static byte* Allocate(size_t size);\n static void Deallocate(byte* pointer, size_t size);\n};\n\n// Gets the currently used allocator for CUDA memory allocation.\nAllocatorBase* GetCudaAllocator();\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/assert.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/core/logger.hpp\"\n\n// Prints a panic message and aborts the program\n#define PANIC(...) \\\n { \\\n ::nvidia::isaac::logger::Log( \\\n __FILE__, __LINE__, ::nvidia::isaac::logger::Severity::PANIC, __VA_ARGS__); \\\n std::abort(); \\\n }\n\n// Checks if an expression evaluates to true. If not prints a panic message and aborts the program.\n#define ASSERT(expr, ...) \\\n if (!(expr)) { \\\n ::nvidia::isaac::logger::Log( \\\n __FILE__, __LINE__, ::nvidia::isaac::logger::Severity::PANIC, __VA_ARGS__); \\\n std::abort(); \\\n }\n\n// Asserts that A == B. If not prints a panic message and aborts the program.\n#define ISAAC_ASSERT_EQ(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n ASSERT( \\\n _va == _vb, \"Assert failed: %s == %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A != B. If not prints a panic message and aborts the program.\n#define ISAAC_ASSERT_NE(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n ASSERT( \\\n _va != _vb, \"Assert failed: %s != %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A > B. If not prints a panic message and aborts the program.\n#define ISAAC_ASSERT_GT(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n ASSERT( \\\n _va > _vb, \"Assert failed: %s > %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A >= B. If not prints a panic message and aborts the program.\n#define ISAAC_ASSERT_GE(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n ASSERT( \\\n _va >= _vb, \"Assert failed: %s >= %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A > B. If not prints a panic message and aborts the program.\n#define ISAAC_ASSERT_LT(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n ASSERT( \\\n _va < _vb, \"Assert failed: %s > %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that A <= B. If not prints a panic message and aborts the program.\n#define ISAAC_ASSERT_LE(exp_a, exp_b) \\\n { \\\n const auto _va = exp_a; \\\n const auto _vb = exp_b; \\\n ASSERT( \\\n _va <= _vb, \"Assert failed: %s <= %s.\", std::to_string(_va).c_str(), \\\n std::to_string(_vb).c_str()); \\\n }\n\n// Asserts that abs(A - B) < threshold. If not prints a panic message and aborts the program.\n#define ISAAC_ASSERT_NEAR(exp_a, exp_b, exp_threshold) \\\n { \\\n const auto _vdiff = exp_a - exp_b; \\\n const auto _vthreshold = exp_threshold; \\\n ASSERT( \\\n std::abs(_vdiff) <= _vthreshold, \\\n \"Assert failed: difference between %s and %s as |%s| <= %s.\", \\\n std::to_string(exp_a).c_str(), std::to_string(exp_b).c_str(), \\\n std::to_string(_vdiff).c_str(), std::to_string(_vthreshold).c_str()); \\\n }\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/buffers/algorithm.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/assert.hpp\"\n#include \"gems/core/buffers/traits.hpp\"\n#include \"gems/core/byte.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Copies raw memory from one buffer to another buffer\nvoid CopyArrayRaw(\n const void* source, BufferStorageMode source_storage, void* target,\n BufferStorageMode target_storage, size_t size);\n\n// Copies data between two buffers layout as matrices\n// For both source and target buffer the pointer and the row stride between rows is given.\n// `row_size` indicates the number of bytes which are actually filled with data. Bytes which are\n// not filled with used data might not be copied.\nvoid CopyMatrixRaw(\n const void* source, size_t source_stride, BufferStorageMode source_storage, void* target,\n size_t target_stride, BufferStorageMode target_storage, size_t rows, size_t row_size);\n\n// Copies memory from one buffer to another buffer\ntemplate \nvoid CopyArray(const Source& source, Target& target) {\n // Asserts that the buffers have the same size\n ASSERT(source.size() == target.size(), \"size mismatch: %zu vs %zu\", source.size(), target.size());\n // Copy the bytes\n auto source_view = View(source).template reinterpret();\n auto target_view = View(target).template reinterpret();\n CopyArrayRaw(\n reinterpret_cast(source_view.begin()), BufferTraits::kStorageMode,\n reinterpret_cast(target_view.begin()), BufferTraits::kStorageMode,\n source_view.size());\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/buffers/buffer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/allocator/allocators.hpp\"\n#include \"gems/core/buffers/traits.hpp\"\n#include \"gems/core/byte.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// -------------------------------------------------------------------------------------------------\n\nnamespace detail {\n\n// A simple pointer which can be tagged. This is used for example to differentiate between a pointer\n// to host memory and a pointer to device memory.\ntemplate \nclass TaggedPointer {\n public:\n using value_t = std::remove_cv_t;\n using const_pointer_t = TaggedPointer;\n using pointer_t = TaggedPointer;\n using tag_t = Tag;\n // Standard constructor\n TaggedPointer(K* data = nullptr) : data_(data) {}\n\n // Default copy\n TaggedPointer(const TaggedPointer& other) = default;\n TaggedPointer& operator=(const TaggedPointer& other) = default;\n\n // Move will set source to nullptr\n TaggedPointer(TaggedPointer&& other) { *this = std::move(other); }\n TaggedPointer& operator=(TaggedPointer&& other) {\n data_ = other.data_;\n other.data_ = nullptr;\n return *this;\n }\n\n // Sets the actual pointer\n TaggedPointer& operator=(K* other) {\n data_ = other;\n return *this;\n }\n // Gets the actual pointer\n K* get() const { return data_; }\n operator K*() const { return data_; }\n\n private:\n K* data_;\n};\n\n} // namespace detail\n\n// -------------------------------------------------------------------------------------------------\n\nnamespace detail {\n\n// Base class for Buffer and BufferView which provides storage for the memory pointer\n// and corresponding dimensions.\ntemplate \nclass BufferBase {\n public:\n using pointer_t = Pointer;\n\n BufferBase() : pointer_(nullptr), size_(0) {}\n\n BufferBase(Pointer pointer, size_t size) : pointer_(std::move(pointer)), size_(size) {}\n\n // pointer to the first row\n const Pointer& pointer() const { return pointer_; }\n // The total size of the buffer in bytes\n size_t size() const { return size_; }\n // A pointer to the first byte of the buffer.\n auto begin() const { return pointer_.get(); }\n // A pointer behind the last byte of the buffer.\n auto end() const { return begin() + size(); }\n\n protected:\n Pointer pointer_;\n size_t size_;\n};\n\n} // namespace detail\n\n// -------------------------------------------------------------------------------------------------\n\n// A buffer which owns its memory\ntemplate \nclass Buffer : public detail::BufferBase {\n public:\n using mutable_view_t = detail::BufferBase;\n using const_view_t = detail::BufferBase;\n\n Buffer() : handle_(nullptr, Deleter{0}) {}\n\n // Allocates memory for `size` bytes.\n Buffer(size_t size)\n : detail::BufferBase(nullptr, size),\n handle_(Allocator::Allocate(size), Deleter{size}) {\n // 1) Initialize the base class with a nullptr, the number of rows, and the desired stride.\n // 2) Allocate memory and store it in the unique pointer used as handle. This will also change\n // the stride stored in the base class to the actual stride chosen by the allocator.\n // 3) Get a pointer to the allocated memory and store it in the base class so that calls to\n // pointer() actually work.\n this->pointer_ = handle_.get();\n }\n\n Buffer(Buffer&& buffer)\n : detail::BufferBase(nullptr, buffer.size_), handle_(std::move(buffer.handle_)) {\n this->pointer_ = handle_.get();\n buffer.pointer_ = nullptr;\n buffer.size_ = 0;\n }\n\n Buffer& operator=(Buffer&& buffer) {\n this->handle_ = std::move(buffer.handle_);\n this->pointer_ = this->handle_.get();\n this->size_ = buffer.size_;\n buffer.pointer_ = nullptr;\n buffer.size_ = 0;\n return *this;\n }\n\n void resize(size_t desired_size) {\n if (desired_size == this->size()) return;\n *this = Buffer(desired_size);\n }\n\n // Disowns the pointer from the buffer. The user is now responsible for deallocation.\n // WARNING: This is dangerous as the wrong allocator might be called.\n byte* release() {\n byte* pointer = handle_.release();\n this->pointer_ = nullptr;\n return pointer;\n }\n\n // Creates a view which provides read and write access from this buffer object.\n mutable_view_t view() { return mutable_view_t(this->pointer_, this->size_, this->stride_); }\n const_view_t view() const {\n return const_view_t(typename Pointer::const_pointer_t(this->pointer_.get()), this->size_);\n }\n // Creates a view which only provides read access from this buffer object.\n const_view_t const_view() const {\n return const_view_t(typename Pointer::const_pointer_t(this->pointer_.get()), this->size_);\n }\n\n private:\n // A deleter object for the unique pointer to free allocated memory\n struct Deleter {\n size_t size;\n void operator()(byte* pointer) {\n if (size == 0) return;\n Allocator::Deallocate(pointer, size);\n }\n };\n\n // A unique pointer is used to handle the allocator and to make this object non-copyable.\n using handle_t = std::unique_ptr;\n\n // Memory handle used to automatically deallocate memory and to disallow copy semantics.\n handle_t handle_;\n};\n\n// -------------------------------------------------------------------------------------------------\n\n// A pointer to host memory\ntemplate \nusing HostPointer =\n detail::TaggedPointer>;\n\n// A host buffer with stride which owns its memory\nusing CpuBuffer = Buffer, CpuAllocator>;\n\n// A host buffer with stride which does not own its memory\nusing CpuBufferView = detail::BufferBase>;\n\n// A host buffer with stride which does not own its memory and provides only read access\nusing CpuBufferConstView = detail::BufferBase>;\n\ntemplate <>\nstruct BufferTraits, CpuAllocator>> {\n static constexpr BufferStorageMode kStorageMode = BufferStorageMode::Host;\n static constexpr bool kIsMutable = true;\n static constexpr bool kIsOwning = true;\n\n using buffer_view_t = CpuBufferView;\n using buffer_const_view_t = CpuBufferConstView;\n};\n\ntemplate \nstruct BufferTraits>> {\n static constexpr BufferStorageMode kStorageMode = BufferStorageMode::Host;\n static constexpr bool kIsMutable = !std::is_const::value;\n static constexpr bool kIsOwning = false;\n\n using buffer_view_t = CpuBufferView;\n using buffer_const_view_t = CpuBufferConstView;\n};\n\n// -------------------------------------------------------------------------------------------------\n\n// A pointer to CUDA memory\ntemplate \nusing CudaPointer =\n detail::TaggedPointer>;\n\n// A CUDA buffer with stride which owns its memory\nusing CudaBuffer = Buffer, CudaAllocator>;\n\n// A CUDA buffer with stride which does not own its memory\nusing CudaBufferView = detail::BufferBase>;\n\n// A CUDA buffer with stride which does not own its memory and provides only read access\nusing CudaBufferConstView = detail::BufferBase>;\n\ntemplate <>\nstruct BufferTraits, CudaAllocator>> {\n static constexpr BufferStorageMode kStorageMode = BufferStorageMode::Cuda;\n static constexpr bool kIsMutable = true;\n static constexpr bool kIsOwning = true;\n\n using buffer_view_t = CudaBufferView;\n using buffer_const_view_t = CudaBufferConstView;\n};\n\ntemplate \nstruct BufferTraits>> {\n static constexpr BufferStorageMode kStorageMode = BufferStorageMode::Cuda;\n static constexpr bool kIsMutable = !std::is_const::value;\n static constexpr bool kIsOwning = false;\n\n using buffer_view_t = CudaBufferView;\n using buffer_const_view_t = CudaBufferConstView;\n};\n\n// -------------------------------------------------------------------------------------------------\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/buffers/traits.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\nnamespace nvidia {\nnamespace isaac {\n\n// Specifies where data is stored, e.g. host or CUDA device\nenum class BufferStorageMode {\n // host memory\n Host,\n // CUDA memory\n Cuda\n};\n\n// Specifies various properties for buffer types.\n// Example:\n// template \n// struct BufferTraits> {\n// static constexpr BufferStorageMode kStorageMode = BufferStorageMode::Cuda;\n// static constexpr bool kIsMutable = true;\n// static constexpr bool kIsOwning = true;\n//\n// static CudaArray Create(size_t size) {\n// return CudaArray(size);\n// }\n// };\ntemplate \nstruct BufferTraits;\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/byte.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\nnamespace nvidia {\nnamespace isaac {\n\n// Will be oficially defined in C++17\nusing byte = uint8_t;\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/constants.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\nnamespace nvidia {\nnamespace isaac {\n\n// The value of pi with 75 digits available for every type.\ntemplate ::value, int>::type = 0>\nconstexpr K Pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286;\n// The value of 2 * pi (a.k.a tau) with 75 digits available for every type.\ntemplate ::value, int>::type = 0>\nconstexpr K TwoPi = 6.283185307179586476925286766559005768394338798750211641949889184615632812572;\n\n// Converts from degree to radians\ntemplate ::value, int>::type = 0>\nconstexpr K DegToRad(K x) {\n return x * K(0.017453292519943295769236907684886127134428718885417254560);\n}\n\n// Converts from radians to degrees\ntemplate ::value, int>::type = 0>\nconstexpr K RadToDeg(K x) {\n return x * K(57.29577951308232087679815481410517033240547246656432154916);\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/epsilon.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n// This file provides functions to help comparing floating point numbers for equality.\n// You should have a look at this excellent article for more details:\n// https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/\n\nnamespace nvidia {\nnamespace isaac {\n\n// A very small floating point number close to what can be represented by the corresponding\n// floating point standard.\n// For more details see https://en.wikipedia.org/wiki/Machine_epsilon\ntemplate \nconstexpr K MachineEpsilon = K(0);\ntemplate <>\nconstexpr float MachineEpsilon = 5.9604644775390625e-8f;\ntemplate <>\nconstexpr double MachineEpsilon = 1.1102230246251565404236316680908203125e-16;\n\n// Returns true if a floating point value can be considered to be zero under floating point\n// rounding errors. This function compares against a custom epsilon.\ntemplate \nbool IsAlmostZero(K x, K epsilon = MachineEpsilon) {\n return std::abs(x) <= epsilon;\n}\n// Returns true if two floating point values are so close that they can be considered to be equal\n// under floating point rounding errors. This function uses relative comparison technique.\n// Warning: Do not use to compare against small floats, or zero, use IsAlmostZero instead.\ntemplate \nbool IsAlmostEqualRelative(K x, K y, K max_rel_diff = K(10) * MachineEpsilon) {\n const K diff = std::abs(x - y);\n const K absx = std::abs(x);\n const K absy = std::abs(y);\n const K larger = (absx > absy) ? absx : absy;\n return (diff <= larger * max_rel_diff);\n}\n\n// Returns true if two floating point values are equal up to a certain tolerance.\ntemplate \nbool IsAlmostEqualAbsolute(K x, K y, K tolerance) {\n return std::abs(x - y) <= tolerance;\n}\n\n// Returns true if a floating point value can be considered to be one under floating point\n// rounding errors. This function compares against machine epsilon.\ntemplate \nbool IsAlmostOne(K x) {\n return std::abs(x - K(1)) <= K(10) * MachineEpsilon;\n}\n\nnamespace epsilon_details {\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wstrict-aliasing\"\n\ninline int32_t Float32AsInteger(float x) {\n return *reinterpret_cast(&x);\n}\n\ninline int64_t Float64AsInteger(double x) {\n return *reinterpret_cast(&x);\n}\n\n#pragma GCC diagnostic pop\n} // namespace epsilon_details\n\n// Checks if two 32-bit floats are equal by computing their ULPs difference.\ninline bool IsAlmostEqualUlps(float x, float y, int32_t max_ulps_diff = 2) {\n const int32_t ix = epsilon_details::Float32AsInteger(x);\n const int32_t iy = epsilon_details::Float32AsInteger(y);\n if ((ix < 0) != (iy < 0)) {\n // In case the sign is different we still need to check if the floats were equal to\n // make sure -0 is equal to +0.\n return (x == y);\n } else {\n return std::abs(ix - iy) < max_ulps_diff;\n }\n}\n\n// Checks if two 64-bit floats are equal by computing their ULPs difference.\ninline bool IsAlmostEqualUlps(double x, double y, int64_t max_ulps_diff = 2) {\n const int64_t ix = epsilon_details::Float64AsInteger(x);\n const int64_t iy = epsilon_details::Float64AsInteger(y);\n if ((ix < 0) != (iy < 0)) {\n // In case the sign is different we still need to check if the floats were equal to\n // make sure -0 is equal to +0.\n return (x == y);\n } else {\n return std::abs(ix - iy) < max_ulps_diff;\n }\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/image/image.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/core/assert.hpp\"\n#include \"gems/core/buffers/buffer.hpp\"\n#include \"gems/core/byte.hpp\"\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/tensor/tensor.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// -------------------------------------------------------------------------------------------------\n\n// A pixel which owns its data and can life independently from the image itself.\ntemplate \nusing Pixel = std::conditional_t>;\n\n// A pixel type used for read and write access to an image pixel.\ntemplate \nusing PixelRef = std::conditional_t>>;\n\n// A pixel type used for read-only access to an image pixel.\ntemplate \nusing PixelConstRef = std::conditional_t>>;\n\nnamespace detail {\n\n// Helper type to create pixels and pixel references based on a pointer for N > 1\ntemplate \nstruct PixelCreator {\n // Creates a non-owning pixel based on a pointer\n static PixelRef CreatePixelRef(K* ptr) { return PixelRef(ptr); }\n // Creates a non-owning, non-mutable pixel based on a pointer\n static PixelConstRef CreatePixelConstRef(const K* ptr) { return PixelConstRef(ptr); }\n};\n\n// Specialized version of PixelCreator for N = 1\ntemplate \nstruct PixelCreator {\n static PixelRef CreatePixelRef(K* ptr) { return *ptr; }\n static PixelConstRef CreatePixelConstRef(const K* ptr) { return *ptr; }\n};\n\n// Helper type to find the correct tensor type based on the number of channels.\ntemplate \nstruct ImageTensorBase {\n using type = TensorBase, BufferType>;\n};\ntemplate \nstruct ImageTensorBase {\n using type = TensorBase, BufferType>;\n};\n\n} // namespace detail\n\n// -------------------------------------------------------------------------------------------------\n\n// A two-dimensional array of pixels\n//\n// Each pixel contains `N` elements and all elements are of the same type `K`. Elements for all\n// pixels are stored continuously. Access to pixels returns mapped memory to provide read access\n// without unnecessary copies and direct write access. Pixels are stored interleaved and in\n// row-major storage order.\n//\n// The image type uses a tensor to store data. If `N` is equal to 1 a rank 2 tensor is used,\n// otherwise a rank 3 tensor is used. The tensor uses the given `BufferType` and more information\n// is provided in the Tensor type.\n//\ntemplate \nclass ImageBase {\n public:\n // The number of channels for an image must be greater than 0.\n static_assert(N > 0, \"Number of channels must be positive\");\n // The number of channels for each pixels. This is also the last dimension of the underlying\n // tensor.\n static constexpr int kChannels = N;\n\n // Tensor type used to store the array of elements for this image.\n using tensor_t = typename detail::ImageTensorBase::type;\n\n using buffer_t = BufferType;\n using buffer_view_t = typename tensor_t::buffer_view_t;\n using buffer_const_view_t = typename tensor_t::buffer_const_view_t;\n static constexpr bool kIsMutable = tensor_t::kIsMutable;\n static constexpr bool kIsOwning = tensor_t::kIsOwning;\n\n using index_t = typename tensor_t::index_t;\n using coordinate_t = Vector2; // Note: Only rows and col are used for coordinates\n using dimensions_t = Vector2; // Note: Only rows and col are used for dimensions\n\n using element_t = typename tensor_t::element_t;\n using element_ptr_t = typename tensor_t::element_ptr_t;\n using element_const_ptr_t = typename tensor_t::element_const_ptr_t;\n\n using raw_ptr_t = typename tensor_t::raw_ptr_t;\n using raw_const_ptr_t = typename tensor_t::raw_const_ptr_t;\n\n // Type used for a pixel owning its memory and thus able to life outside of this image\n using pixel_t = Pixel;\n // Type used when accessing pixels which provides read and write access to pixel data.\n using pixel_ref_t = PixelRef;\n // Type used when accessing pixels which provides only read access to pixel data.\n using pixel_const_ref_t = PixelConstRef;\n\n // Type for a mutable view on this image\n using image_view_t = ImageBase;\n // Type for a non-mutable view on this image\n using image_const_view_t = ImageBase;\n\n // Create an empty image object\n ImageBase() = default;\n\n // Create an image object of given dimensions. This will create a new storage container and is\n // only available for storage container types which own their memory. This function is templated\n // on the integer type so that we can distable this constructor for non-owning storage types.\n ImageBase(const dimensions_t& dimensions) : tensor_(dimensions[0], dimensions[1]) {}\n ImageBase(index_t rows, index_t cols) : tensor_(rows, cols) {}\n\n // Create an image object of given dimensions and with given storage container\n ImageBase(buffer_t buffer, const dimensions_t& dimensions)\n : tensor_(std::move(buffer), dimensions[0], dimensions[1]) {}\n ImageBase(buffer_t buffer, index_t rows, index_t cols) : tensor_(std::move(buffer), rows, cols) {}\n\n // Creates an image from a tensor.\n ImageBase(tensor_t tensor) : tensor_(std::move(tensor)) {}\n\n // Copy construction uses the default behavior\n ImageBase(const ImageBase& other) = default;\n // Copy assignment uses the default behavior\n ImageBase& operator=(const ImageBase& other) = default;\n // Move construction uses the default behavior\n ImageBase(ImageBase&& other) = default;\n // Move assignment uses the default behavior\n ImageBase& operator=(ImageBase&& other) = default;\n\n // Creates a mutable view on this tensor\n template \n std::enable_if_t view() {\n return image_view_t({this->data().begin(), this->data().size()}, this->dimensions());\n }\n // Creates a non-mutable view on this tensor\n image_const_view_t const_view() const {\n return image_const_view_t({this->data().begin(), this->data().size()}, this->dimensions());\n }\n image_const_view_t view() const { return const_view(); }\n\n // Provides conversion to a mutable view for owning images and mutable views.\n template \n operator std::enable_if_t() {\n return view();\n }\n // Provides conversion to a non-mutable view\n operator image_const_view_t() const { return const_view(); }\n\n // Returns true if this image has dimensions 0\n bool empty() const { return rows() == 0 || cols() == 0; }\n // (rows, cols) as a 2-vector\n dimensions_t dimensions() const { return dimensions_t{rows(), cols()}; }\n // Returns the number of rows\n index_t rows() const { return tensor().dimensions()[0]; }\n // Returns the number of cols\n index_t cols() const { return tensor().dimensions()[1]; }\n // The number of channels\n constexpr int channels() const { return kChannels; }\n // The total number of pixels in the image\n index_t num_pixels() const { return rows() * cols(); }\n\n // Resizes the image\n template \n std::enable_if_t resize(index_t desired_rows, index_t desired_cols) {\n tensor_.resize(desired_rows, desired_cols);\n }\n template \n std::enable_if_t resize(const dimensions_t& dimensions) {\n tensor_.resize(dimensions[0], dimensions[1]);\n }\n\n // Returns true if the given pixel coordinate references a valid pixel.\n bool isValidCoordinate(index_t row, index_t col) const {\n return 0 <= row && row < rows() && 0 <= col && col < cols();\n }\n\n // Returns a non mutable reference pixel holder on the position (row, col).\n pixel_const_ref_t operator()(index_t row, index_t col) const {\n return detail::PixelCreator::CreatePixelConstRef(\n row_pointer(row) + col * kChannels);\n }\n pixel_const_ref_t operator()(const coordinate_t& coordinate) const {\n return this->operator()(coordinate[0], coordinate[1]);\n }\n // Returns a mutable reference pixel holder on the position (row, col).\n template \n std::enable_if_t operator()(index_t row, index_t col) {\n return detail::PixelCreator::CreatePixelRef(row_pointer(row) + col * kChannels);\n }\n template \n std::enable_if_t operator()(const coordinate_t& coordinate) {\n return this->operator()(coordinate[0], coordinate[1]);\n }\n\n // Returns a non mutable reference pixel holder at the position `index`.\n pixel_const_ref_t operator[](index_t index) const {\n return detail::PixelCreator::CreatePixelConstRef(\n element_wise_begin() + index * kChannels);\n }\n // Returns a mutable reference pixel holder at the position `index`.\n template \n std::enable_if_t operator[](index_t index) {\n return detail::PixelCreator::CreatePixelRef(\n element_wise_begin() + index * kChannels);\n }\n\n // Pointers to the first element of the first pixel\n element_const_ptr_t element_wise_begin() const { return tensor().element_wise_begin(); }\n element_ptr_t element_wise_begin() { return tensor().element_wise_begin(); }\n // Pointers behind the last element of the last pixel\n element_const_ptr_t element_wise_end() const { return tensor().element_wise_end(); }\n element_ptr_t element_wise_end() { return tensor().element_wise_end(); }\n // The total number of elements in the image\n index_t num_elements() const { return num_pixels() * channels(); }\n\n // Pointer to the first element in the i-th row in an image\n element_ptr_t row_pointer(index_t row) { return element_wise_begin() + row * cols() * kChannels; }\n element_const_ptr_t row_pointer(index_t row) const {\n return element_wise_begin() + row * cols() * kChannels;\n }\n\n // Number of bytes used to store one row of the image in memory.\n size_t getStride() const { return ByteCount(1, cols()); }\n // Number of bytes which are used for elements of an image of the given number of rows and columns\n static size_t ByteCount(index_t rows, index_t cols) {\n ASSERT(rows >= 0, \"Number of rows must not be negative: %d\", rows);\n ASSERT(cols >= 0, \"Number of cols must not be negative: %d\", cols);\n // Note: Number of channels are guaranteed to be positive.\n return static_cast(rows * cols * kChannels) * sizeof(K);\n }\n\n // The underlying tensor object\n const tensor_t& tensor() const { return tensor_; }\n template \n std::enable_if_t tensor() {\n return tensor_;\n }\n\n // The underlying buffer object\n const buffer_t& data() const { return tensor().data(); }\n template \n std::enable_if_t data() {\n return tensor().data();\n }\n\n private:\n tensor_t tensor_;\n};\n\n// -------------------------------------------------------------------------------------------------\n\n// An image which owns it's memory\ntemplate \nusing Image = ImageBase;\n\n// A mutable view on an image which does not own memory but can be used to read and write the\n// data of the underlying image.\ntemplate \nusing ImageView = ImageBase;\n\n// A non-mutable view on an image which does not own the memory and can only be used to read\n// the data of the underlying image.\ntemplate \nusing ImageConstView = ImageBase;\n\n#define ISAAC_DECLARE_CPU_IMAGE_TYPES_IMPL(N, T, S) \\\n using Image##N##S = Image; \\\n using ImageView##N##S = ImageView; \\\n using ImageConstView##N##S = ImageConstView; \\\n using Pixel##N##S = Pixel; \\\n using PixelRef##N##S = PixelRef; \\\n using PixelConstRef##N##S = PixelConstRef;\n\n#define ISAAC_DECLARE_CPU_IMAGE_TYPES(N) \\\n template \\\n using Image##N = Image; \\\n template \\\n using ImageView##N = ImageView; \\\n template \\\n using ImageConstView##N = ImageConstView; \\\n ISAAC_DECLARE_CPU_IMAGE_TYPES_IMPL(N, uint8_t, ub) \\\n ISAAC_DECLARE_CPU_IMAGE_TYPES_IMPL(N, uint16_t, ui16) \\\n ISAAC_DECLARE_CPU_IMAGE_TYPES_IMPL(N, int, i) \\\n ISAAC_DECLARE_CPU_IMAGE_TYPES_IMPL(N, double, d) \\\n ISAAC_DECLARE_CPU_IMAGE_TYPES_IMPL(N, float, f)\n\nISAAC_DECLARE_CPU_IMAGE_TYPES(1)\nISAAC_DECLARE_CPU_IMAGE_TYPES(2)\nISAAC_DECLARE_CPU_IMAGE_TYPES(3)\nISAAC_DECLARE_CPU_IMAGE_TYPES(4)\n\n#undef ISAAC_DECLARE_CPU_IMAGE_TYPES\n#undef ISAAC_DECLARE_CPU_IMAGE_TYPES_IMPL\n\n// -------------------------------------------------------------------------------------------------\n// Helper function to create an image view from a pointer using dense storage\ntemplate \nImageView CreateImageView(\n K* data, typename ImageView::index_t rows, typename ImageView::index_t cols) {\n ASSERT(rows >= 0, \"Number of rows must not be negative - was %d\", rows);\n ASSERT(cols >= 0, \"Number of columns must not be negative - was %d\", cols);\n const size_t size = ImageView::ByteCount(rows, cols);\n return ImageView(CpuBufferView(reinterpret_cast(data), size), rows, cols);\n}\n\n// Helper function to create an image const view from a pointer using dense storage\ntemplate \nImageConstView CreateImageConstView(\n const K* data, typename ImageConstView::index_t rows,\n typename ImageConstView::index_t cols) {\n ASSERT(rows >= 0, \"Number of rows must not be negative - was %d\", rows);\n ASSERT(cols >= 0, \"Number of columns must not be negative - was %d\", cols);\n const size_t size = ImageConstView::ByteCount(rows, cols);\n return ImageConstView(\n CpuBufferConstView(reinterpret_cast(data), size), rows, cols);\n}\n\n// -------------------------------------------------------------------------------------------------\n\n// An image stored in device memory which owns it's memory\ntemplate \nusing CudaImage = ImageBase;\n\n// A mutable view on an image which is stored on GPU device memory, does not own memory, but can be\n// used to read and write the data of the underlying image.\ntemplate \nusing CudaImageView = ImageBase;\n\n// A non-mutable view on an image which is stored on GPU device memory, does not own its memory, and\n// can only be used to read the data of the underlying image.\ntemplate \nusing CudaImageConstView = ImageBase;\n\n// Helper macro for ISAAC_DECLARE_CUDA_IMAGE_TYPES\n#define ISAAC_DECLARE_CUDA_IMAGE_TYPES_IMPL(N, K, S) \\\n using CudaImage##N##S = CudaImage; \\\n using CudaImageView##N##S = CudaImageView; \\\n using CudaImageConstView##N##S = CudaImageConstView;\n\n// Helper macro to define various CudaImage types\n#define ISAAC_DECLARE_CUDA_IMAGE_TYPES(N) \\\n template \\\n using CudaImage##N = CudaImage; \\\n template \\\n using CudaImageView##N = CudaImageView; \\\n template \\\n using CudaImageConstView##N = CudaImageConstView; \\\n ISAAC_DECLARE_CUDA_IMAGE_TYPES_IMPL(N, uint8_t, ub) \\\n ISAAC_DECLARE_CUDA_IMAGE_TYPES_IMPL(N, uint16_t, ui16) \\\n ISAAC_DECLARE_CUDA_IMAGE_TYPES_IMPL(N, int, i) \\\n ISAAC_DECLARE_CUDA_IMAGE_TYPES_IMPL(N, double, d) \\\n ISAAC_DECLARE_CUDA_IMAGE_TYPES_IMPL(N, float, f)\n\nISAAC_DECLARE_CUDA_IMAGE_TYPES(1)\nISAAC_DECLARE_CUDA_IMAGE_TYPES(2)\nISAAC_DECLARE_CUDA_IMAGE_TYPES(3)\nISAAC_DECLARE_CUDA_IMAGE_TYPES(4)\n\n// -------------------------------------------------------------------------------------------------\n// Helper function to create a CUDA image view from a pointer using dense storage\ntemplate \nCudaImageView CreateCudaImageView(\n K* data, typename CudaImageView::index_t rows,\n typename CudaImageView::index_t cols) {\n ASSERT(rows >= 0, \"Number of rows must not be negative - was %d\", rows);\n ASSERT(cols >= 0, \"Number of columns must not be negative - was %d\", cols);\n const size_t size = CudaImageView::ByteCount(rows, cols);\n return CudaImageView(CudaBufferView(reinterpret_cast(data), size), rows, cols);\n}\n\n// Helper function to create a CUDA image const view from a pointer using dense storage\ntemplate \nCudaImageConstView CreateCudaImageConstView(\n const K* data, typename CudaImageConstView::index_t rows,\n typename CudaImageConstView::index_t cols) {\n ASSERT(rows >= 0, \"Number of rows must not be negative - was %d\", rows);\n ASSERT(cols >= 0, \"Number of columns must not be negative - was %d\", cols);\n const size_t size = CudaImageConstView::ByteCount(rows, cols);\n return CudaImageConstView(\n CudaBufferConstView(reinterpret_cast(data), size), rows, cols);\n}\n\n// -------------------------------------------------------------------------------------------------\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/logger.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n// Logs a debug message\n#define LOG_DEBUG(...) \\\n ::nvidia::isaac::logger::Log( \\\n __FILE__, __LINE__, ::nvidia::isaac::logger::Severity::DEBUG, __VA_ARGS__)\n\n// Logs an informational message\n#define LOG_INFO(...) \\\n ::nvidia::isaac::logger::Log( \\\n __FILE__, __LINE__, ::nvidia::isaac::logger::Severity::INFO, __VA_ARGS__)\n\n// Logs a warning\n#define LOG_WARNING(...) \\\n ::nvidia::isaac::logger::Log( \\\n __FILE__, __LINE__, ::nvidia::isaac::logger::Severity::WARNING, __VA_ARGS__)\n\n// Logs an error\n#define LOG_ERROR(...) \\\n ::nvidia::isaac::logger::Log( \\\n __FILE__, __LINE__, ::nvidia::isaac::logger::Severity::ERROR, __VA_ARGS__)\n\nnamespace nvidia {\nnamespace isaac {\nnamespace logger {\n\n// Indicates the level of severity for a log message\nenum class Severity {\n // A utility case which can be used for `SetSeverity` to disable all severity levels.\n NONE = -2,\n // A utility case which can be used for `Redirect` and `SetSeverity`\n ALL = -1,\n // The five different log severities in use from most severe to least severe.\n PANIC = 0, // Need to start at 0\n ERROR,\n WARNING,\n INFO,\n DEBUG,\n // A utility case representing the number of log levels used internally.\n COUNT\n};\n\n// Function which is used for logging. It can be changed to intercept the logged messages.\nextern void (*LoggingFunction)(const char* file, int line, Severity severity, const char* log);\n\n// Redirects the output for a given log severity.\nvoid Redirect(std::FILE* file, Severity severity = Severity::ALL);\n\n// Redirects the output for a given file log severity up to and including a given log severity.\nvoid RedirectFileLog(std::FILE* file, Severity severity = Severity::DEBUG);\n\n// Sets global log severity thus effectively disabling all logging with lower severity\nvoid SetSeverity(Severity severity);\n\n// Converts the message and argument into a string and pass it to LoggingFunction.\ntemplate \nvoid Log(const char* file, int line, Severity severity, const char* txt, ...) {\n va_list args1;\n va_start(args1, txt);\n va_list args2;\n va_copy(args2, args1);\n std::vector buf(1 + std::vsnprintf(NULL, 0, txt, args1));\n va_end(args1);\n std::vsnprintf(buf.data(), buf.size(), txt, args2);\n va_end(args2);\n LoggingFunction(file, line, severity, buf.data());\n}\n\n// Helper datastructure for Singleton\nstruct SeverityContainer {\n Severity r = Severity::DEBUG;\n};\n\n} // namespace logger\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/math/macros.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#ifdef __CUDACC__\n#define CUDA_BOTH __host__ __device__\n#define CUDA_BOTH_INLINE __forceinline__ __host__ __device__\n#define CUDA_INLINE __forceinline__ __device__\n#else\n#define CUDA_BOTH\n#define CUDA_BOTH_INLINE __inline__\n#endif // __CUDACC__\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/math/pose2.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/core/math/so2.hpp\"\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/math/utils.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Class for 2D transformation.\ntemplate \nstruct Pose2 {\n using Scalar = K;\n static constexpr int kDimension = 2;\n\n SO2 rotation;\n Vector2 translation;\n\n // Returns identity transformation\n static Pose2 Identity() { return Pose2{SO2::Identity(), Vector2::Zero()}; }\n // Creates a translation transformation\n static Pose2 Translation(const Vector2& translation) {\n return Pose2{SO2::Identity(), translation};\n }\n static Pose2 Translation(K x, K y) { return Pose2{SO2::Identity(), Vector2{x, y}}; }\n // Creates a rotation transformation\n static Pose2 Rotation(const K angle) {\n return Pose2{SO2::FromAngle(angle), Vector2::Zero()};\n }\n // Creates a pose from position and angle\n static Pose2 FromXYA(K px, K py, K angle) {\n return Pose2{SO2::FromAngle(angle), Vector2{px, py}};\n }\n // Creates a pose from matrix transformation\n static Pose2 FromMatrix(const Matrix3& matrix) {\n return Pose2{\n SO2::FromNormalized(matrix(0, 0), matrix(1, 0)), Vector2(matrix(0, 2), matrix(1, 2))};\n }\n\n // Returns the inverse transformation\n Pose2 inverse() const {\n const SO2 inv = rotation.inverse();\n return Pose2{inv, -(inv * translation)};\n }\n\n // Returns the transformation as a matrix\n Matrix3 matrix() const {\n Matrix3 ret;\n ret << rotation.cos(), -rotation.sin(), translation.x(), rotation.sin(), rotation.cos(),\n translation.y(), K(0), K(0), K(1);\n return ret;\n }\n\n // Casts to a different type\n template ::value, int> = 0>\n Pose2 cast() const {\n return Pose2{rotation.template cast(), translation.template cast()};\n }\n template ::value, int> = 0>\n const Pose2& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n\n // Composition of Pose2\n friend Pose2 operator*(const Pose2& lhs, const Pose2& rhs) {\n return Pose2{lhs.rotation * rhs.rotation, lhs.rotation * rhs.translation + lhs.translation};\n }\n // Transforms a vector 2D with the given 2D transformation\n friend Vector2 operator*(const Pose2& pose, const Vector2& vec) {\n return pose.rotation * vec + pose.translation;\n }\n // Exponentaiton of the transformation\n Pose2 pow(K exponent) const {\n const K angle = rotation.angle();\n const K half_angle = angle / K(2);\n const K csc_sin =\n IsAlmostZero(angle)\n ? exponent * (K(1) + (K(1) - exponent * exponent) * half_angle * half_angle / K(6))\n : std::sin(half_angle * exponent) / std::sin(half_angle);\n const SO2 rot = SO2::FromAngle(half_angle * (exponent - K(1)));\n return Pose2{SO2::FromAngle(angle * exponent), csc_sin * (rot * translation)};\n }\n};\n\nusing Pose2d = Pose2;\nusing Pose2f = Pose2;\n\n// The \"exponential\" map from three-dimensional tangent space to SE(2) manifold space\n// For SE(2) this function encodes the tangent space as a three-dimensional vector (tx, ty, a)\n// where (tx, ty) is the translation component and a is the angle.\ntemplate \nPose2 Pose2Exp(const Vector3& tangent) {\n return Pose2{SO2::FromAngle(tangent[2]), tangent.template head<2>()};\n}\n\n// The \"logarithmic\" map from manifold to tangent space\n// This computes the tangent for a pose relative to the identity pose. Log and exp are inverse\n// to each other.\ntemplate \nVector3 Pose2Log(const Pose2& pose) {\n return Vector3{pose.translation.x(), pose.translation.y(), pose.rotation.angle()};\n}\n\n// Returns true if given pose is almost identity.\ntemplate \nbool IsPoseAlmostIdentity(const Pose2& pose) {\n return IsAlmostZero(pose.translation.x()) && IsAlmostZero(pose.translation.y()) &&\n IsAlmostOne(pose.rotation.cos());\n}\n\n// Returns distance to identity pose in position and angle.\n// First element of the return value is for position, the seconds is for angle.\ntemplate \nVector2 PoseMagnitude(const Pose2& pose) {\n return {pose.translation.norm(), std::abs(pose.rotation.angle())};\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/math/pose3.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/core/math/pose2.hpp\"\n#include \"gems/core/math/so3.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Class for 3D transformation.\ntemplate \nstruct Pose3 {\n using Scalar = K;\n static constexpr int kDimension = 3;\n\n SO3 rotation;\n Vector3 translation;\n\n // Returns identity transformation\n CUDA_BOTH static Pose3 Identity() { return Pose3{SO3::Identity(), Vector3::Zero()}; }\n // Creates a translation transformation\n CUDA_BOTH static Pose3 Translation(const Vector3& translation) {\n return Pose3{SO3::Identity(), translation};\n }\n CUDA_BOTH static Pose3 Translation(K x, K y, K z) {\n return Pose3{SO3::Identity(), Vector3{x, y, z}};\n }\n // Creates a translation transformation\n CUDA_BOTH static Pose3 Rotation(const Vector3& axis, K angle) {\n return Pose3{SO3::FromAxisAngle(axis, angle), Vector3::Zero()};\n }\n // Creates a 3D pose from a 2D pose in the XY plane\n CUDA_BOTH static Pose3 FromPose2XY(const Pose2& pose) {\n return Pose3{\n SO3::FromSO2XY(pose.rotation),\n Vector3{pose.translation.x(), pose.translation.y(), K(0)}};\n }\n // Creates a pose from matrix transformation\n CUDA_BOTH static Pose3 FromMatrix(const Matrix4& matrix) {\n return Pose3{\n SO3::FromNormalizedQuaternion(Quaternion(matrix.template topLeftCorner<3, 3>())),\n matrix.template topRightCorner<3, 1>()};\n }\n\n // Returns the inverse transformation\n CUDA_BOTH Pose3 inverse() const {\n const auto inv = rotation.inverse();\n return Pose3{inv, -(inv * translation)};\n }\n\n // Returns the transformation as a matrix\n CUDA_BOTH Matrix4 matrix() const {\n Matrix4 ret;\n ret.template topLeftCorner<3, 3>() = rotation.matrix();\n ret.template topRightCorner<3, 1>() = translation;\n ret.template bottomLeftCorner<1, 3>().setZero();\n ret(3, 3) = K(1);\n return ret;\n }\n\n // Casts to a different type\n template ::value, int> = 0>\n CUDA_BOTH Pose3 cast() const {\n return Pose3{rotation.template cast(), translation.template cast()};\n }\n template ::value, int> = 0>\n CUDA_BOTH const Pose3& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n\n // Converts to a 2D pose in the XY plane\n CUDA_BOTH Pose2 toPose2XY() const {\n return Pose2{rotation.toSO2XY(), translation.template head<2>()};\n }\n\n // Composition of poses\n CUDA_BOTH friend Pose3 operator*(const Pose3& lhs, const Pose3& rhs) {\n return Pose3{lhs.rotation * rhs.rotation, lhs.rotation * rhs.translation + lhs.translation};\n }\n // Transforms a vector 2D with the given 2D transformation\n CUDA_BOTH friend Vector3 operator*(const Pose3& pose, const Vector3& vec) {\n return pose.rotation * vec + pose.translation;\n }\n // Exponentaiton of the transformation\n CUDA_BOTH Pose3 pow(K exponent) const {\n // First step: align the rotation vector with the z axis.\n const K angle = WrapPi(rotation.angle());\n if (IsAlmostZero(angle)) {\n // TODO(bbutin): Use Taylor expension in that case?\n return Pose3{rotation, exponent * translation};\n }\n const Vector3 axis = rotation.axis();\n const Vector3 cross = axis.cross(Vector3(K(0), K(0), K(1)));\n const K cos = axis.z();\n const K sin = cross.norm();\n\n Matrix3 rot = Matrix3::Identity() * cos;\n // If axis is align in the Z direction, the matrix above will do the trick, if not we compute\n // rotation matrix to transform the axis in the Z axis.\n if (!IsAlmostZero(sin)) {\n // TODO(bbutin): Use Taylor expension in case sin ~ 0?\n const Vector3 unit = cross / sin;\n rot += (1.0 - cos) * unit * unit.transpose();\n rot(0, 1) += -cross.z();\n rot(0, 2) += cross.y();\n rot(1, 2) += -cross.x();\n rot(1, 0) += cross.z();\n rot(2, 0) += -cross.y();\n rot(2, 1) += cross.x();\n }\n // Now we can compute the exponentation the same way as for the 2d for x and y, while z will\n // just be linearly FromScaledAxis\n const K half_angle = angle / K(2);\n const K csc_sin =\n IsAlmostZero(angle)\n ? exponent * (K(1) + (K(1) - exponent * exponent) * half_angle * half_angle / K(6))\n : std::sin(half_angle * exponent) / std::sin(half_angle);\n const SO2 rot2 = SO2::FromAngle(half_angle * (exponent - K(1)));\n const Vector3 t = rot * translation;\n const Vector2 xy = csc_sin * (rot2 * t.template head<2>());\n const SO3 final_rotation = SO3::FromAngleAxis(angle * exponent, axis);\n return Pose3{final_rotation, rot.inverse() * Vector3(xy.x(), xy.y(), t.z() * exponent)};\n }\n};\n\nusing Pose3d = Pose3;\nusing Pose3f = Pose3;\n\n// The \"exponential\" map of SE(3) which maps a tangent space element to the manifold space\n// For SE(3) this function encodes the tangent space as a six-dimensional vector\n// (px, py, pz, rx, ry, rz) where (px, py, pz) is the translation component and (rx, ry, rz) is the\n// scaled rotation axis.\ntemplate \nCUDA_BOTH Pose3 Pose3Exp(const Vector6& tangent) {\n return Pose3{SO3::FromScaledAxis(tangent.template tail<3>()), tangent.template head<3>()};\n}\n\n// The \"logarithmic\" map of SE(3) which maps a manifold space element to the tangent space\n// This computes the tangent for a pose relative to the identity pose. Log and exp are inverse\n// to each other.\ntemplate \nCUDA_BOTH Vector6 Pose3Log(const Pose3& pose) {\n Vector6 result;\n result.template head<3>() = pose.translation;\n result.template tail<3>() = pose.rotation.angle() * pose.rotation.axis();\n return result;\n}\n\n// Returns true if given pose is almost identity.\ntemplate \nCUDA_BOTH bool IsPoseAlmostIdentity(const Pose3& pose) {\n return IsAlmostZero(pose.translation.norm()) && IsAlmostZero(pose.rotation.angle());\n}\n\n// Returns distance to identity pose in position and angle.\n// First element of the return value is for position, the seconds is for angle.\ntemplate \nCUDA_BOTH Vector2 PoseMagnitude(const Pose3& pose) {\n return {pose.translation.norm(), static_cast(std::abs(pose.rotation.angle()))};\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/math/so2.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/core/assert.hpp\"\n#include \"gems/core/epsilon.hpp\"\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/math/utils.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Class for 2D rotation\ntemplate \nclass SO2 {\n public:\n using Scalar = K;\n static constexpr int kDimension = 2;\n\n // Creates an undefined rotation\n // Note: Use Identity to create the identity rotation\n SO2() {}\n\n // Return identity rotation\n CUDA_BOTH static SO2 Identity() {\n SO2 q;\n q.cos_sin_ = Vector2(K(1), K(0));\n return q;\n }\n // Creates rotation from an angle\n // Note: This uses calls to trigonometric functions.\n CUDA_BOTH static SO2 FromAngle(K angle) {\n SO2 q;\n q.cos_sin_ = Vector2(std::cos(angle), std::sin(angle));\n return q;\n }\n // Creates rotation from a not necessarily normalized direction vector\n CUDA_BOTH static SO2 FromDirection(const Vector2& direction) {\n SO2 q;\n const K norm = direction.norm();\n ASSERT(!IsAlmostZero(norm), \"Direction vector must not be 0\");\n q.cos_sin_ = direction / norm;\n return q;\n }\n CUDA_BOTH static SO2 FromDirection(K dx, K dy) { return FromDirection(Vector2(dx, dy)); }\n // Creates from a normalized cos/sin direction angle\n CUDA_BOTH static SO2 FromNormalized(const Vector2& cos_sin) {\n ASSERT(\n IsAlmostEqualRelative(cos_sin.squaredNorm(), K(1)),\n \"Given cos/sin vector is not normalized: %lf\", cos_sin.norm());\n SO2 q;\n q.cos_sin_ = cos_sin;\n return q;\n }\n CUDA_BOTH static SO2 FromNormalized(K cos_angle, K sin_angle) {\n return FromNormalized(Vector2(cos_angle, sin_angle));\n }\n\n // Access to cosine and sine of the rotation angle.\n // Note this is a simple getter and deos not call trigonometric functions.\n CUDA_BOTH K cos() const { return cos_sin_[0]; }\n CUDA_BOTH K sin() const { return cos_sin_[1]; }\n // Access to cos and sin of the rotation angle as a direction vector.\n const Vector2& asDirection() const { return cos_sin_; }\n\n // Returns the rotation angle in range [-PI;PI]\n // Note: This uses a call to a trigonometric function.\n CUDA_BOTH K angle() const { return std::atan2(sin(), cos()); }\n // Return Rotation matrix\n CUDA_BOTH Matrix2 matrix() const {\n Matrix2 m;\n m(0, 0) = cos();\n m(0, 1) = -sin();\n m(1, 0) = sin();\n m(1, 1) = cos();\n return m;\n }\n // Inverse Rotation\n CUDA_BOTH SO2 inverse() const { return SO2::FromNormalized(cos(), -sin()); }\n\n // Casts to a different type\n template ::value, int> = 0>\n CUDA_BOTH SO2 cast() const {\n // We need to re-normalize in the new type\n return SO2::FromDirection(asDirection().template cast());\n }\n template ::value, int> = 0>\n CUDA_BOTH const SO2& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n\n // Rotation composition\n CUDA_BOTH friend SO2 operator*(const SO2& lhs, const SO2& rhs) {\n return FromDirection(\n lhs.cos() * rhs.cos() - lhs.sin() * rhs.sin(),\n lhs.sin() * rhs.cos() + lhs.cos() * rhs.sin());\n }\n // Rotates a vector 2D\n CUDA_BOTH friend Vector2 operator*(const SO2& lhs, const Vector2& vec) {\n return Vector2(\n lhs.cos() * vec[0] - lhs.sin() * vec[1], lhs.sin() * vec[0] + lhs.cos() * vec[1]);\n }\n\n private:\n Vector2 cos_sin_;\n};\n\nusing SO2d = SO2;\nusing SO2f = SO2;\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/math/so3.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/core/math/macros.hpp\"\n#include \"gems/core/math/so2.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Class for 3D rotation\ntemplate \nclass SO3 {\n public:\n using Scalar = K;\n static constexpr int kDimension = 3;\n\n // Creates an empty un-initialized quaternion\n // Note: Use Identity to create an identity rotation.\n SO3() {}\n\n // Return identity rotation\n CUDA_BOTH static SO3 Identity() { return SO3(Quaternion::Identity()); }\n // Creates a rotation which rotates by around the given axes by the magnitude of the axis\n CUDA_BOTH static SO3 FromScaledAxis(const Vector3& axis_angle) {\n const K norm = axis_angle.norm();\n if (IsAlmostZero(norm)) {\n return SO3::Identity();\n } else {\n return SO3(Quaternion(Eigen::AngleAxis(norm, axis_angle / norm)));\n }\n }\n // Creates a rotation which rotates by an angle around a given (not necessarily normalized) axis\n CUDA_BOTH static SO3 FromAxisAngle(const Vector3& axis, K angle) {\n return SO3(Quaternion(Eigen::AngleAxis(angle, axis.normalized())));\n }\n CUDA_BOTH static SO3 FromAngleAxis(K angle, const Vector3& axis) {\n return SO3(Quaternion(Eigen::AngleAxis(angle, axis.normalized())));\n }\n // Creates rotation from a (not necessarily normalized) quaternion\n CUDA_BOTH static SO3 FromQuaternion(const Quaternion& quaternion) {\n return SO3(quaternion.normalized());\n }\n // Creates rotation from a normalized quaternion\n // Note: This will assert if the quaternion does not have unit length.\n CUDA_BOTH static SO3 FromNormalizedQuaternion(const Quaternion& quaternion) {\n ASSERT(\n IsAlmostEqualRelative(quaternion.squaredNorm(), K(1)),\n \"Given cos/sin vector is not normalized: %lf\", quaternion.norm());\n return SO3(quaternion);\n }\n // Creates a 3D rotation from a 2D rotation in the XY plane\n CUDA_BOTH static SO3 FromSO2XY(const SO2& rotation) {\n return FromAxisAngle({K(0), K(0), K(1)}, rotation.angle());\n }\n // Creates rotation from a 3x3 rotation matrix\n CUDA_BOTH static SO3 FromMatrix(const Matrix& matrix) {\n return SO3(Quaternion(matrix).normalized());\n }\n\n // Returns the rotation axis\n CUDA_BOTH Vector3 axis() const { return quaternion_.coeffs().head(3).normalized(); }\n // Returns the angle of rotation around the axis\n // Note: This calls a trigonometric function.\n CUDA_BOTH K angle() const {\n return K(2) * std::atan2(quaternion_.coeffs().head(3).norm(), quaternion_.coeffs().w());\n }\n // Returns the quaternion representation of the rotation\n CUDA_BOTH const Quaternion& quaternion() const { return quaternion_; }\n // Returns the matrix representation of the rotation\n CUDA_BOTH Matrix3 matrix() const { return quaternion_.toRotationMatrix(); }\n\n // Returns the roll, pitch, yaw euler angles of the rotation\n CUDA_BOTH Vector3 eulerAnglesRPY() const {\n const Vector3d euler_angles = quaternion_.toRotationMatrix().eulerAngles(0, 1, 2);\n // Make sure the roll is in range [-Pi/2, Pi/2]\n if (std::abs(euler_angles[0]) > Pi * K(0.5)) {\n return Vector3d(\n WrapPi(euler_angles[0] + Pi), WrapPi(Pi - euler_angles[1]),\n WrapPi(euler_angles[2] + Pi));\n }\n return euler_angles;\n }\n\n // Returns the inverse rotation.\n CUDA_BOTH SO3 inverse() const {\n // conjugate == inverse iff quaternion_.norm() == 1\n return SO3(quaternion_.conjugate());\n }\n\n // Casts to a different type\n template ::value, int> = 0>\n CUDA_BOTH SO3 cast() const {\n // We need to re-normalize in the new type\n return SO3::FromQuaternion(quaternion().template cast());\n }\n template ::value, int> = 0>\n CUDA_BOTH const SO3& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n\n // Converts to a 2D rotation in the XY plane\n CUDA_BOTH SO2 toSO2XY() const {\n // 2D rotation matrix:\n // cos(a) -sin(a)\n // sin(a) cos(a)\n // Quaternion to 3D rotation matrix:\n // 1 - 2*(qy^2 + qz^2) 2*(qx*qy - qz*qw) ...\n // 2*(qx*qy + qz*qw) 1 - 2*(qx^2 + qz^2) ...\n // It follows (modulo re-normalization):\n // cos(a) = 1 - (qx^2 + qy^2 + 2*qz^2)\n // sin(a) = 2*qz*qw\n // These formulas correspond to the half-angle formulas for sin/cos.\n const K qx = quaternion_.x();\n const K qy = quaternion_.y();\n const K qz = quaternion_.z();\n const K qw = quaternion_.w();\n const K cos_a = K(1) - (qx * qx + qy * qy + K(2) * qz * qz);\n const K sin_a = K(2) * qz * qw;\n return SO2::FromDirection(cos_a, sin_a);\n }\n\n // Rotation composition\n CUDA_BOTH friend SO3 operator*(const SO3& lhs, const SO3& rhs) {\n return FromQuaternion(lhs.quaternion_ * rhs.quaternion_);\n }\n // Rotates a vector 3D by the given rotation\n CUDA_BOTH friend Vector3 operator*(const SO3& rot, const Vector3& vec) {\n // TODO: faster implementation\n return (rot.quaternion_ * Quaternion(K(0), vec.x(), vec.y(), vec.z()) *\n rot.quaternion_.conjugate())\n .coeffs()\n .head(3);\n }\n\n // Create rotation from roll/pitch/yaw Euler angles\n CUDA_BOTH static SO3 FromEulerAnglesRPY(K roll_angle, K pitch_angle, K yaw_angle) {\n SO3 roll = SO3::FromAngleAxis(roll_angle, {K(1), K(0), K(0)});\n SO3 pitch = SO3::FromAngleAxis(pitch_angle, {K(0), K(1), K(0)});\n SO3 yaw = SO3::FromAngleAxis(yaw_angle, {K(0), K(0), K(1)});\n return roll * pitch * yaw;\n }\n // Create rotation from Euler angles in order (roll, pitch, yaw)\n CUDA_BOTH static SO3 FromEulerAnglesRPY(const Vector3d& roll_pitch_yaw) {\n return FromEulerAnglesRPY(roll_pitch_yaw[0], roll_pitch_yaw[1], roll_pitch_yaw[2]);\n }\n\n // Computes the jacobian of the rotation of normal vector. Plane normal only has rotation\n // component.\n CUDA_BOTH Matrix vectorRotationJacobian(const Vector3& n) const {\n // Ref: https://www.weizmann.ac.il/sci-tea/benari/sites/sci-tea.benari/files/uploads/\n // softwareAndLearningMaterials/quaternion-tutorial-2-0-1.pdf\n // Rotation Matrix in Quaternion (R):\n // [w^2 + x^2 - y^2 - z^2 2xy - 2wz 2wy + 2xz]\n // [2wz + 2xy w^2 - x^2 + y^2 - z^2 2yz - 2wx]\n // [2xz - 2wy 2wx + 2yz w^2 - x^2 - y^2 + z^2]\n const K qx = quaternion_.x();\n const K qy = quaternion_.y();\n const K qz = quaternion_.z();\n const K qw = quaternion_.w();\n Matrix result;\n result << K(2) * (qw * n[0] - qz * n[1] + qy * n[2]),\n K(2) * (qx * n[0] + qy * n[1] + qz * n[2]), K(-2) * (qy * n[0] - qx * n[1] - qw * n[2]),\n K(-2) * (qz * n[0] + qw * n[1] - qx * n[2]),\n\n K(2) * (qz * n[0] + qw * n[1] - qx * n[2]), K(2) * (qy * n[0] - qx * n[1] - qw * n[2]),\n K(2) * (qx * n[0] + qy * n[1] + qz * n[2]), K(2) * (qw * n[0] - qz * n[1] + qy * n[2]),\n\n K(-2) * (qy * n[0] - qx * n[1] - qw * n[2]), K(2) * (qz * n[0] + qw * n[1] - qx * n[2]),\n K(-2) * (qw * n[0] - qz * n[1] + qy * n[2]), K(2) * (qx * n[0] + qy * n[1] + qz * n[2]);\n return result;\n }\n\n private:\n SO3(const Quaternion& quaternion) : quaternion_(quaternion) {}\n\n Quaternion quaternion_;\n};\n\nusing SO3d = SO3;\nusing SO3f = SO3;\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/math/types.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/math/macros.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\ntemplate \nusing Matrix = Eigen::Matrix;\ntemplate \nusing Vector = Eigen::Matrix;\n\ntemplate \nusing RowVector = Eigen::Matrix;\ntemplate \nusing ColVector = Eigen::Matrix;\n\ntemplate \nusing VectorX = Vector;\nusing VectorXd = VectorX;\nusing VectorXf = VectorX;\nusing VectorXi = VectorX;\nusing VectorXub = VectorX;\n\nusing VectorXcf = Eigen::VectorXcf;\n\ntemplate \nusing RowVectorX = RowVector;\nusing RowVectorXf = RowVectorX;\n\ntemplate \nusing ColVectorX = ColVector;\nusing ColVectorXf = ColVectorX;\n\ntemplate \nusing MatrixX = Matrix;\nusing MatrixXd = MatrixX;\nusing MatrixXf = MatrixX;\nusing MatrixXi = MatrixX;\n\nusing MatrixXcf = Eigen::MatrixXcf;\n\n#define DEFINE_MATRIX_TYPES(N) \\\n template \\\n using Matrix##N = Matrix; \\\n using Matrix##N##d = Matrix##N; \\\n using Matrix##N##f = Matrix##N; \\\n using Matrix##N##i = Matrix##N;\n\nDEFINE_MATRIX_TYPES(2)\nDEFINE_MATRIX_TYPES(3)\nDEFINE_MATRIX_TYPES(4)\nDEFINE_MATRIX_TYPES(5)\nDEFINE_MATRIX_TYPES(6)\nDEFINE_MATRIX_TYPES(7)\nDEFINE_MATRIX_TYPES(8)\n\n#undef DEFINE_MATRIX_TYPES\n\n// Matrix types with fixed number of rows but dynamic number of columns.\n// Useful to store and efficiently manipulate sets of geometric entities, e.g. points and planes.\n// 2xN: 2D points in Euclidean coordinates\n// 3xN: 2D points in homogeneous coordinates or 3D points in Euclidean coordinates\n// 4xN: planes or 3D points in homogeneous coordinates\n#define DEFINE_FIXED_ROWS_MATRIX_TYPES(N) \\\n template \\\n using Matrix##N##X = Matrix; \\\n using Matrix##N##Xd = Matrix##N##X; \\\n using Matrix##N##Xf = Matrix##N##X; \\\n using Matrix##N##Xi = Matrix##N##X;\n\nDEFINE_FIXED_ROWS_MATRIX_TYPES(2)\nDEFINE_FIXED_ROWS_MATRIX_TYPES(3)\nDEFINE_FIXED_ROWS_MATRIX_TYPES(4)\nDEFINE_FIXED_ROWS_MATRIX_TYPES(5)\nDEFINE_FIXED_ROWS_MATRIX_TYPES(6)\nDEFINE_FIXED_ROWS_MATRIX_TYPES(7)\nDEFINE_FIXED_ROWS_MATRIX_TYPES(8)\n\n#undef DEFINE_FIXED_ROWS_MATRIX_TYPES\n\ntemplate \nusing Matrix34 = Matrix;\nusing Matrix34d = Matrix34;\nusing Matrix34f = Matrix34;\nusing Matrix34i = Matrix34;\n\ntemplate \nusing Matrix43 = Matrix;\nusing Matrix43d = Matrix43;\nusing Matrix43f = Matrix43;\nusing Matrix43i = Matrix43;\n\n#define DEFINE_VECTOR_TYPES(N) \\\n template \\\n using Vector##N = Vector; \\\n using Vector##N##d = Vector##N; \\\n using Vector##N##f = Vector##N; \\\n using Vector##N##i = Vector##N; \\\n using Vector##N##ub = Vector##N;\n\nDEFINE_VECTOR_TYPES(2)\nDEFINE_VECTOR_TYPES(3)\nDEFINE_VECTOR_TYPES(4)\nDEFINE_VECTOR_TYPES(5)\nDEFINE_VECTOR_TYPES(6)\nDEFINE_VECTOR_TYPES(7)\nDEFINE_VECTOR_TYPES(8)\n\n#undef DEFINE_VECTOR_TYPES\n\ntemplate \nusing Quaternion = Eigen::Quaternion;\nusing Quaterniond = Quaternion;\nusing Quaternionf = Quaternion;\n\n// Helper function to compute the sum of two quaternions\ntemplate \nCUDA_BOTH Quaternion operator+(const Quaternion& lhs, const Quaternion& rhs) {\n return Quaternion(lhs.coeffs() + rhs.coeffs());\n}\n// Helper function to compute the difference of two quaternions\ntemplate \nCUDA_BOTH Quaternion operator-(const Quaternion& lhs, const Quaternion& rhs) {\n return Quaternion(lhs.coeffs() - rhs.coeffs());\n}\n// Unary - operator for a quaternion\ntemplate \nCUDA_BOTH Quaternion operator-(const Quaternion& q) {\n return Quaternion(-q.coeffs());\n}\n\ntemplate \nusing EigenImage = Eigen::Array;\ntemplate \nusing EigenImageMap = Eigen::Map>;\ntemplate \nusing EigenImageConstMap = Eigen::Map>;\n\n// A base helper for constructing Views of data as eigen matrix maps.\ntemplate <\n typename K, int Rows = Eigen::Dynamic, int Cols = Eigen::Dynamic, int MatrixOptions = 0,\n int MapOptions = 0, int OuterStride = 0, int InnerStride = 0>\nusing EigenMatrixView = Eigen::Map<\n Eigen::Matrix, MapOptions,\n Eigen::Stride>;\n\n// A base helper for constructing const Views of data as eigen matrix maps.\ntemplate <\n typename K, int Rows = Eigen::Dynamic, int Cols = Eigen::Dynamic, int MatrixOptions = 0,\n int MapOptions = 0, int OuterStride = 0, int InnerStride = 0>\nusing EigenMatrixConstView = Eigen::Map<\n const Eigen::Matrix, MapOptions,\n Eigen::Stride>;\n\n// A base helper for constructing Views of data as eigen vector maps.\ntemplate <\n typename K, int Rows = Eigen::Dynamic, int MapOptions = 0, int OuterStride = 0,\n int InnerStride = 0>\nusing EigenVectorView =\n Eigen::Map, MapOptions, Eigen::Stride>;\n\n// A base helper for constructing const Views of data as eigen vector maps.\ntemplate <\n typename K, int Rows = Eigen::Dynamic, int MapOptions = 0, int OuterStride = 0,\n int InnerStride = 0>\nusing EigenVectorConstView = Eigen::Map<\n const Eigen::Matrix, MapOptions, Eigen::Stride>;\n\n// A base helper for constructing Views of data as eigen row vector maps.\ntemplate <\n typename K, int Cols = Eigen::Dynamic, int MapOptions = 0, int OuterStride = 0,\n int InnerStride = 0>\nusing EigenRowVectorView = Eigen::Map<\n Eigen::Matrix, MapOptions,\n Eigen::Stride>;\n\n// A base helper for constructing const Views of data as eigen row vector maps.\ntemplate <\n typename K, int Cols = Eigen::Dynamic, int MapOptions = 0, int OuterStride = 0,\n int InnerStride = 0>\nusing EigenRowVectorConstView = Eigen::Map<\n const Eigen::Matrix, MapOptions,\n Eigen::Stride>;\n\n// Creates a Vector from an initializer list\ntemplate \nCUDA_BOTH Vector MakeVector(const K (&elements)[N]) {\n Vector result;\n for (size_t i = 0; i < N; i++) {\n result[i] = elements[i];\n }\n return result;\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/math/utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/core/assert.hpp\"\n#include \"gems/core/constants.hpp\"\n#include \"gems/core/epsilon.hpp\"\n#include \"gems/core/math/macros.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Returns square of a number. This is alternative to using std::pow(number, 2).\ntemplate \nCUDA_BOTH K Square(K number) {\n return number * number;\n}\n\n// Returns an angle within the range ]-Pi, Pi] that is equivalent to `angle`:\n// WrapPi(angle) == angle + k*2*Pi (k being an integer)\ntemplate \nCUDA_BOTH K WrapPi(K angle) {\n // Use -angle in order to include Pi and exclude -Pi\n const K d = std::floor((Pi - angle) / TwoPi);\n return angle + d * TwoPi;\n}\n\n// Returns an angle within the range [0, 2*Pi[ that is equivalent to `angle`:\n// WrapTwoPi(angle) == angle + k*2*Pi (k being an integer)\ntemplate \nCUDA_BOTH K WrapTwoPi(K angle) {\n while (angle >= TwoPi) angle -= TwoPi;\n while (angle < K(0)) angle += TwoPi;\n return angle;\n}\n\n// Returns the difference between two angles in the range ]-Pi, Pi]\n// Warning to not use the result to compare to zero if the angles are big.\ntemplate \nCUDA_BOTH K DeltaAngle(K x, K y) {\n return WrapPi(x - y);\n}\n\n// Returns the average of two angles in the range ]-Pi, Pi]\ntemplate \nCUDA_BOTH K MeanAngle(K x, K y) {\n return WrapPi(y + 0.5 * DeltaAngle(x, y));\n}\n\n// Computes a unit vector at given angle (anti clock-wise from x-axis)\ntemplate \nCUDA_BOTH Vector2 AngleVector(K angle) {\n return Vector2{std::cos(angle), std::sin(angle)};\n}\n\n// Limits the absolute of a value\ntemplate \nCUDA_BOTH K LimitAbs(K x, K max) {\n return x < -max ? -max : (x > max ? max : x);\n}\n\n// Clamps a value to the given interval [xmin, xmax]\ntemplate \nCUDA_BOTH K Clamp(K x, K xmin, K xmax) {\n return x < xmin ? xmin : (x > xmax ? xmax : x);\n}\n// Clamps a value to the unit interval [0, 1]\ntemplate \nCUDA_BOTH K Clamp01(K x) {\n return Clamp(x, K(0), K(1));\n}\n\n// Safely cast a floating point number into an integral type and clamp the result in the range\n// [min, max]. If NaN is provided as input, then max will be returned.\ntemplate <\n typename K, typename I, typename std::enable_if_t::value, int> = 0,\n typename std::enable_if_t::value, int> = 0>\nCUDA_BOTH I SafeClampAndCast(K value, I min, I max) {\n if (value < static_cast(min)) {\n return min;\n }\n if (value < static_cast(max)) {\n return static_cast(value);\n }\n return max;\n}\n\n// Convenience function which calls std::floor and stores the result in a 32-bit integer.\ntemplate ::value, int> = 0>\nCUDA_BOTH int FloorToInt(K value) {\n return static_cast(std::floor(value));\n}\n\n// Rounds a double to a 32-bit integer using a nifty trick. This function only works if the double\n// is within reasonable range.\nCUDA_BOTH_INLINE int FastRoundDoubleToInt32(double x) {\n union {\n double real;\n int integer;\n } q;\n q.real = x + 6755399441055744.0;\n return q.integer;\n}\n\n// Convenience function which calls std::floor and stores the result in a 32-bit integer.\ntemplate ::value, int> = 0>\nCUDA_BOTH int FloorToIntWithReminder(K value, K& reminder) {\n const K floor_value = std::floor(value);\n reminder = value - floor_value;\n return static_cast(floor_value);\n}\n\n// Computes 0 <= a such that k*n + a = x for 0 <= k < n\nCUDA_BOTH_INLINE int PositiveModulo(int x, int n) {\n const int k = x % n;\n return (k < 0 ? k + n : k);\n}\n\n// Computes smallest q such that q * b >= a for a >= 0 and b > 0. If a or b are out of bounds\n// -1 is returned.\nCUDA_BOTH_INLINE int CeilDivision(int a, int b) {\n if (a < 0 || b <= 0) return -1;\n return (a / b) + (a % b != 0 ? 1 : 0); // Note the assumption is that / and % are computed\n // as part of the same operation.\n}\n\n// Returns whether or not two vectors are colinear\ntemplate \nCUDA_BOTH bool IsColinear(const Vector& a, const Vector& b) {\n const K dot = a.dot(b);\n // If dot is null, either one of the vector is null which means the two vectors are colinear, if\n // not then the two vectors are orthogonal so obviously not colinear.\n if (IsAlmostZero(dot)) {\n return IsAlmostZero(a.squaredNorm()) || IsAlmostZero(b.squaredNorm());\n }\n // a.dot(b) / (||a|| * ||b||) = cos(alpha) where alpha is the angle between both vector;\n // Taking the square of it avoid the use of sqrt and both vector are colinear iff |cos(alpha)| = 1\n return IsAlmostOne(dot * dot / (a.squaredNorm() * b.squaredNorm()));\n}\n\n// Returns the cross product of Vector2 defined as:\n// AxB = ||A||*||B||*sin(A/B);\ntemplate \nCUDA_BOTH K CrossProduct(const Vector2& a, const Vector2& b) {\n return a.x() * b.y() - a.y() * b.x();\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/optional.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)\n\n#include \n\n#else\n\n#include \n\nnamespace std {\nusing experimental::make_optional;\nusing experimental::nullopt;\nusing experimental::optional;\n} // namespace std\n\n#endif\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/tensor/sample_cloud.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2019-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/core/tensor/tensor.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// -------------------------------------------------------------------------------------------------\n\nnamespace sample_cloud_details {\n\n// Helper type to find the correct tensor type based on the number of channels.\ntemplate \nstruct SampleCloudImpl {\n using type = TensorBase, Buffer>;\n};\ntemplate \nstruct SampleCloudImpl {\n using type = TensorBase, Buffer>;\n};\n\n} // namespace sample_cloud_details\n\n// A sample cloud is identical to a (X, N) tensor.\ntemplate \nusing SampleCloudBase = typename sample_cloud_details::SampleCloudImpl::type;\n\n// -------------------------------------------------------------------------------------------------\n\ntemplate \nusing SampleCloud = SampleCloudBase;\n\ntemplate \nusing SampleCloudView = SampleCloudBase;\n\ntemplate \nusing SampleCloudConstView = SampleCloudBase;\n\n#define ISAAC_DECLARE_SAMPLE_CLOUD_TYPES_IMPL(N, T, S) \\\n using SampleCloud##N##S = SampleCloud; \\\n using SampleCloudView##N##S = SampleCloudView; \\\n using SampleCloudConstView##N##S = SampleCloudConstView;\n\n#define ISAAC_DECLARE_SAMPLE_CLOUD_TYPES(N) \\\n template \\\n using SampleCloud##N = SampleCloud; \\\n template \\\n using SampleCloudView##N = SampleCloudView; \\\n template \\\n using SampleCloudConstView##N = SampleCloudConstView; \\\n ISAAC_DECLARE_SAMPLE_CLOUD_TYPES_IMPL(N, uint8_t, ub) \\\n ISAAC_DECLARE_SAMPLE_CLOUD_TYPES_IMPL(N, uint16_t, ui16) \\\n ISAAC_DECLARE_SAMPLE_CLOUD_TYPES_IMPL(N, int, i) \\\n ISAAC_DECLARE_SAMPLE_CLOUD_TYPES_IMPL(N, double, d) \\\n ISAAC_DECLARE_SAMPLE_CLOUD_TYPES_IMPL(N, float, f)\n\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(1)\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(2)\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(3)\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(4)\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(5)\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(6)\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(7)\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(8)\nISAAC_DECLARE_SAMPLE_CLOUD_TYPES(9)\n\n#undef ISAAC_DECLARE_SAMPLE_CLOUD_TYPES\n#undef ISAAC_DECLARE_SAMPLE_CLOUD_TYPES_IMPL\n\n// -------------------------------------------------------------------------------------------------\n\ntemplate \nusing CudaSampleCloud = SampleCloudBase;\n\ntemplate \nusing CudaSampleCloudView = SampleCloudBase;\n\ntemplate \nusing CudaSampleCloudConstView = SampleCloudBase;\n\n#define ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES_IMPL(N, T, S) \\\n using CudaSampleCloud##N##S = CudaSampleCloud; \\\n using CudaSampleCloudView##N##S = CudaSampleCloudView; \\\n using CudaSampleCloudConstView##N##S = CudaSampleCloudConstView;\n\n#define ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(N) \\\n template \\\n using CudaSampleCloud##N = CudaSampleCloud; \\\n template \\\n using CudaSampleCloudView##N = CudaSampleCloudView; \\\n template \\\n using CudaSampleCloudConstView##N = CudaSampleCloudConstView; \\\n ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES_IMPL(N, uint8_t, ub) \\\n ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES_IMPL(N, uint16_t, ui16) \\\n ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES_IMPL(N, int, i) \\\n ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES_IMPL(N, double, d) \\\n ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES_IMPL(N, float, f)\n\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(1)\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(2)\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(3)\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(4)\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(5)\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(6)\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(7)\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(8)\nISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES(9)\n\n#undef ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES\n#undef ISAAC_DECLARE_CUDA_SAMPLE_CLOUD_TYPES_IMPL\n\n// -------------------------------------------------------------------------------------------------\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/core/tensor/tensor.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2019-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"gems/core/assert.hpp\"\n#include \"gems/core/buffers/buffer.hpp\"\n#include \"gems/core/byte.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// -------------------------------------------------------------------------------------------------\n\nnamespace tensor {\nnamespace details {\n\n// A compile-time sequence of integer\ntemplate \nusing int_sequence = std::integer_sequence;\n\n// Helper type to define repeated_int_sequence\ntemplate \nstruct repeated_int_sequence_impl {\n using type = typename repeated_int_sequence_impl::type;\n};\ntemplate \nstruct repeated_int_sequence_impl<0, V, D...> {\n using type = int_sequence;\n};\n\n// A compile-time sequence of integers which are all identical\ntemplate \nusing repeated_int_sequence = typename repeated_int_sequence_impl::type;\n\ntemplate \nstruct DropFirstImpl;\n\ntemplate \nstruct DropFirstImpl> {\n using type = int_sequence;\n};\n\n// Compute the logical AND for a list of arguments\ntemplate \nstruct VariadicAnd : std::integral_constant::value> {};\ntemplate \nstruct VariadicAnd : std::integral_constant {};\n\n} // namespace details\n\n// This value can be used for tensor dimensions to indicate that the size is not fixed at compile\n// time and will instead be provided at runtime. We use the same value as Eigen to be compatible.\nconstexpr int kDynamic = Eigen::Dynamic;\n\n// A compile-time list of integers used to specify tensor dimensions.\ntemplate \nusing Dimensions = details::int_sequence;\n\n// A compile-time list of integers used to specify tensor dimensions which are all dynamic.\ntemplate \nusing Rank = details::repeated_int_sequence;\n\ntemplate \nusing DropFirst = typename details::DropFirstImpl::type;\n\n// Gets the i-th element in an integer sequence\ntemplate \nconstexpr int IntSequenceAt(Dimensions, int i) {\n constexpr int arr[] = {Ints...};\n return i < 0 ? 0 : arr[i];\n}\n\n// Gets the last element in an integer sequence\ntemplate \nconstexpr int IntSequenceLast(Dimensions) {\n constexpr int arr[] = {Ints...};\n return arr[sizeof...(Ints) - 1];\n}\n\n// Gets a vector of dimensions based on the compile-time dimensions and the dimensions given as\n// arguments. If the compile-time dimension is dynamic (-1) the dimension passed as an argument\n// will be used instead. Otherwise the compile-time dimension must match the argument dimension.\n// Dimensions must not be negative with the exception of using -1 for compile-time dimensions. It is\n// also possible to obmit trailing argument dimensions if they are fixed at compile time.\ntemplate \nVector GetDimensionsVector(Args... dimensions) {\n constexpr int kRank = sizeof...(Dimensions);\n constexpr int kArgumentCount = sizeof...(Args);\n std::array compile_time_dimensions{Dimensions...};\n // TODO(dweikersdorf) Use explicit conversion to int\n Vector runtime_dimensions(dimensions...);\n Vector result;\n for (int i = 0; i < kRank; i++) {\n if (i >= kArgumentCount) {\n // The dimension was not specified as an argument. Thus use the compile-time dimension\n ASSERT(\n compile_time_dimensions[i] != -1,\n \"Dimension argument can only be obmitted if the \"\n \"dimension is specified at compile-time\");\n ASSERT(\n compile_time_dimensions[i] > 0,\n \"Dimension argument can only be obmitted if the \"\n \"compile-time dimension is positive. Was: %d\",\n compile_time_dimensions[i]);\n result[i] = compile_time_dimensions[i];\n } else {\n // The dimension was specified as an argument. Use if it the compile-time dimension is -1.\n // Otherwise they both need to argree.\n ASSERT(\n compile_time_dimensions[i] == -1 || compile_time_dimensions[i] == runtime_dimensions[i],\n \"dimension mismatch: %d vs %d\", compile_time_dimensions[i], runtime_dimensions[i]);\n ASSERT(runtime_dimensions[i] >= 0, \"dimensions must not be negative: %d\", result[i]);\n result[i] = runtime_dimensions[i];\n }\n }\n return result;\n}\n\n// Gets a vector of dimensions based the template parameters. For a dimension of dynamic size a\n// size of zero will be chosen.\ntemplate \nVector GetDimensionsVector() {\n constexpr int kRank = sizeof...(Dimensions);\n std::array compile_time_dimensions{Dimensions...};\n Vector result;\n for (int i = 0; i < kRank; i++) {\n if (compile_time_dimensions[i] == kDynamic) {\n result[i] = 0;\n } else {\n ASSERT(\n compile_time_dimensions[i] > 0,\n \"Compile-time dimensions must be positive or Dynamic \"\n \"Was: %d\",\n compile_time_dimensions[i]);\n result[i] = compile_time_dimensions[i];\n }\n }\n return result;\n}\n\n} // namespace tensor\n\n// -------------------------------------------------------------------------------------------------\n\ntemplate \nstruct TensorBase;\n\n// A multi-dimensional array of elements.\n//\n// All elements are of the same type `K`.\n//\n// The tensor stores a multi-dimensional array of elements. The sizes of the array are specified by\n// the template parameter `Dimensions`. An std::integer_sequence of ints is used as type for the\n// list of dimensions. For each axes the dimension can either be a positive integer which indicates\n// a compile-time dimension or it can be `tensor::Dynamic` (which is -1) which indicates that the\n// dimension is specified at runtime. The template `tensor::Dimensions<...>` can be used as an alias\n// for `std::integer_sequence`. The template `tensor::Rank` can be used as an alias for\n// `std::integer_sequence`.\n//\n// Elements are stored in a buffer of type `Buffer`. Most notably buffers can either own memory or\n// just be a view on memory owned by someone else. Buffers can also either allow or not allow\n// modifications of elements.\ntemplate \nclass TensorBase, Buffer> {\n public:\n // Tensor is not allowed. Use TensorConstView instead.\n static_assert(!std::is_const::value, \"Tensor can only be used with non-const element type\");\n\n // The integer sequence containing the sizes of the tensor\n using Dimensions = tensor::details::int_sequence;\n // The rank of the tensor is the number of its dimensions.\n static constexpr int kRank = sizeof...(DimensionsPack);\n // The rank must be greater than 0.\n static_assert(kRank > 0, \"Rank must be at least 1\");\n // @deprecated\n static constexpr int Order = kRank;\n\n // The underlying buffer object used to store elements.\n using buffer_t = Buffer;\n // Type for mutable views on the underlying buffer\n using buffer_view_t = typename BufferTraits::buffer_view_t;\n // Type for non-mutable views on the underlying buffer\n using buffer_const_view_t = typename BufferTraits::buffer_const_view_t;\n // A mutable tensor allows modification of elements.\n static constexpr bool kIsMutable = BufferTraits::kIsMutable;\n // An owning tensor owns its memory while a non-owning memory uses memory owned by another party.\n static constexpr bool kIsOwning = BufferTraits::kIsOwning;\n\n // The integral type used for a single row or column index.\n using index_t = int;\n // The vector type to use for pixel coordinates.\n using coordinate_t = Vector;\n // The vector type to use for pixel dimensions.\n using dimensions_t = Vector;\n\n using element_t = std::remove_cv_t;\n using element_const_ptr_t = std::add_const_t*;\n using element_ptr_t = std::conditional_t;\n\n using element_const_ref_t = std::add_const_t&;\n using element_ref_t = std::conditional_t;\n\n using raw_const_ptr_t = std::add_const_t*;\n using raw_ptr_t = std::conditional_t;\n\n using tensor_view_t = TensorBase;\n using tensor_const_view_t = TensorBase;\n\n TensorBase() {\n // If no dimensions are provided set to zero.\n setDimensions(tensor::GetDimensionsVector());\n }\n\n // Constructs a tensor with the given dimensions which owns its data.\n TensorBase(const dimensions_t& dimensions) { resize(dimensions, true); }\n template <\n typename... RequestedDimensionsPack,\n std::enable_if_t...>::value>* = nullptr>\n TensorBase(RequestedDimensionsPack... dimensions)\n : TensorBase(tensor::GetDimensionsVector(dimensions...)) {}\n\n // Constructs a tensor based on an existing buffer object using the given dimensions. This\n // constructor will throw if the provided buffer does not contain enough data.\n TensorBase(buffer_t data, const dimensions_t& dimensions) : data_(std::move(data)) {\n ASSERT(CheckDimensions(dimensions), \"Trying to create tensor with invalid dimensions\");\n setDimensions(dimensions);\n ASSERT(\n data_.size() >= byte_size(), \"Buffer too small: provided %zd, required %zd\", data_.size(),\n byte_size());\n }\n template <\n typename... RequestedDimensionsPack,\n std::enable_if_t...>::value>* = nullptr>\n TensorBase(buffer_t data, RequestedDimensionsPack... dimensions)\n : TensorBase(std::move(data), tensor::GetDimensionsVector(dimensions...)) {\n }\n\n // Copy construction uses the default behavior\n TensorBase(const TensorBase& other) = default;\n // Copy assignment uses the default behavior1\n TensorBase& operator=(const TensorBase& other) = default;\n // Move construction uses the default behavior\n TensorBase(TensorBase&& other) { *this = std::move(other); }\n // Move assignment uses the default behavior\n TensorBase& operator=(TensorBase&& other) {\n data_ = std::move(other.data_);\n // The dimensions of the tensor.\n dimensions_ = other.dimensions_;\n offsets_ = other.offsets_;\n other.dimensions_.setZero();\n other.offsets_.setZero();\n return *this;\n }\n\n // Creates a mutable view on this tensor\n template \n std::enable_if_t view() {\n return tensor_view_t({this->data().begin(), this->data().size()}, this->dimensions());\n }\n // Creates a non-mutable view on this tensor\n tensor_const_view_t const_view() const {\n return tensor_const_view_t({this->data().begin(), this->data().size()}, this->dimensions());\n }\n\n // Provides conversion to a mutable view for owning tensors and mutable views.\n template \n operator std::enable_if_t() {\n return view();\n }\n // Provides conversion to a non-mutable view\n operator tensor_const_view_t() const { return const_view(); }\n\n // Returns true if any dimension of this tensor is 0 and thus if the number of elements stored in\n // this tensor is 0.\n bool empty() const { return element_count() == 0; }\n // Returns the rank of the tensor\n constexpr int rank() const { return kRank; }\n // Deprecated - use rank() instead\n constexpr int order() const { return kRank; }\n // Returns the dimensions of the tensor\n dimensions_t dimensions() const { return dimensions_; }\n\n // Resizes the tensor. This operation is destructive.\n template \n std::enable_if_t resize(\n const dimensions_t& dimensions, bool force_reallocation = false) {\n // Only allocate new memory if the dimensions change.\n if (force_reallocation || dimensions != dimensions_) {\n ASSERT(CheckDimensions(dimensions), \"Invalid dimensions\");\n setDimensions(dimensions);\n data_ = buffer_t(byte_size());\n }\n }\n\n // Similar as `resize` but takes dimensions individually without using the vector type.\n template <\n typename... RequestedDimensionsPack, bool X = kIsMutable, std::enable_if_t* = nullptr>\n void resize(RequestedDimensionsPack... requested_dimensions) {\n return resize(tensor::GetDimensionsVector(requested_dimensions...));\n }\n\n // Returns true if the element coordinate is within the tensor's dimension\n bool isValidCoordinate(const coordinate_t& indicies) const {\n return (indicies.array() >= 0).all() && (indicies.array() < dimensions_.array()).all();\n }\n\n // Helper wrappers for isValidCoordinate for the most common orders of tensors\n template * = nullptr>\n bool isValidCoordinate(Args... indices) const {\n return isValidCoordinate(coordinate_t(indices...)); // TODO(dweikersdorf) Use explict casts\n }\n\n // Accesses the given index in the tensor with respect to memory ordering\n template ::value>\n std::enable_if_t operator()(const coordinate_t& indicies) const {\n return *(this->element_wise_begin() + indexToOffset(indicies));\n }\n // Accesses the given index in the tensor with respect to memory ordering\n template ::value>\n std::enable_if_t operator()(const coordinate_t& indicies) const {\n return *(this->element_wise_begin() + indexToOffset(indicies));\n }\n\n // Accesses the given index in the tensor with respect to memory ordering\n template \n std::enable_if_t operator()(const coordinate_t& indicies) {\n return *(this->element_wise_begin() + indexToOffset(indicies));\n }\n\n // Helper wrappers for operator access for the most common orders of tensors\n template <\n typename... Args,\n std::enable_if_t::value>* = nullptr>\n element_t operator()(Args... indices) const {\n return operator()(coordinate_t(indices...)); // TODO(dweikersdorf) Use explict casts\n }\n // Helper wrappers for operator access for the most common orders of tensors\n template <\n typename... Args,\n std::enable_if_t::value>* = nullptr>\n element_const_ref_t operator()(Args... indices) const {\n return operator()(coordinate_t(indices...)); // TODO(dweikersdorf) Use explict casts\n }\n // Helper wrappers for operator access for the most common orders of tensors\n template * = nullptr>\n element_ref_t operator()(Args... indices) {\n return operator()(coordinate_t(indices...)); // TODO(dweikersdorf) Use explict casts\n }\n\n // Creates a view on a slice with one dimension less. The dimension with highest significance\n // is sliced.\n template = 2>\n std::enable_if_t, buffer_view_t>> slice(\n index_t index) {\n using slice_t = TensorBase, buffer_view_t>;\n const size_t slice_size = static_cast(offsets_[0]) * sizeof(K);\n const size_t slice_offset = static_cast(index) * slice_size;\n return slice_t(\n buffer_view_t{this->data().begin() + slice_offset, slice_size},\n this->dimensions().template segment(1).eval());\n }\n template = 2>\n std::enable_if_t, buffer_const_view_t>> slice(\n index_t index) {\n return const_slice(index);\n }\n\n // Creates a const view on a slice with one dimension less. The dimension with highest\n // significance is sliced.\n template = 2>\n std::enable_if_t, buffer_const_view_t>>\n const_slice(index_t index) const {\n using const_slice_t = TensorBase, buffer_const_view_t>;\n const size_t slice_size = static_cast(offsets_[0]) * sizeof(K);\n const size_t slice_offset = static_cast(index) * slice_size;\n return const_slice_t(\n buffer_const_view_t{this->data().begin() + slice_offset, slice_size},\n this->dimensions().template segment(1).eval());\n }\n\n // Helper types for Eigen matrix-style access\n static constexpr int kBackDim2 = tensor::IntSequenceAt(Dimensions{}, kRank - 2);\n static constexpr int kBackDim1 = tensor::IntSequenceAt(Dimensions{}, kRank - 1);\n using matrix_view_t = Eigen::Map>;\n using matrix_const_view_t =\n Eigen::Map>;\n using vector_view_t = Eigen::Map>;\n using vector_const_view_t = Eigen::Map>;\n\n // Returns a mutable Eigen matrix view sliced on the last two dimensions\n template <\n typename... Args, std::enable_if_t* = nullptr>\n matrix_view_t matrix(Args... indices) {\n return matrix_view_t(\n this->element_wise_begin() + indexToOffset(coordinate_t(indices..., 0, 0)),\n dimensions_[kRank - 2], dimensions_[kRank - 1]);\n }\n // Returns a non-mutable Eigen matrix view sliced on the last two dimensions\n template * = nullptr>\n matrix_const_view_t matrix(Args... indices) const {\n return matrix_const_view_t(\n this->element_wise_begin() + indexToOffset(coordinate_t(indices..., 0, 0)),\n dimensions_[kRank - 2], dimensions_[kRank - 1]);\n }\n // Returns a mutable Eigen vector view sliced on the last dimension\n template <\n typename... Args, std::enable_if_t* = nullptr>\n vector_view_t matrix(Args... indices) {\n return vector_view_t(\n this->element_wise_begin() + indexToOffset(coordinate_t(indices..., 0)),\n dimensions_[kRank - 1]);\n }\n // Returns a non-mutable Eigen vector view sliced on the last dimension\n template * = nullptr>\n vector_const_view_t matrix(Args... indices) const {\n return vector_const_view_t(\n this->element_wise_begin() + indexToOffset(coordinate_t(indices..., 0)),\n dimensions_[kRank - 1]);\n }\n\n // When indices are omitted in operator() access it behaves the same as `matrix()`.\n template <\n typename... Args,\n std::enable_if_t<\n (sizeof...(Args) == kRank - 2 || sizeof...(Args) == kRank - 1) && kIsMutable>* = nullptr>\n auto operator()(Args... indices) {\n return matrix(indices...);\n }\n // When indices are omitted in operator() access it behaves the same as `matrix()`.\n template <\n typename... Args,\n std::enable_if_t* = nullptr>\n auto operator()(Args... indices) const {\n return matrix(indices...);\n }\n\n // Const Pointer to the beginning of the data block\n element_const_ptr_t element_wise_begin() const {\n return reinterpret_cast(data_.begin());\n }\n // Pointer to the beginning of the data block\n element_ptr_t element_wise_begin() { return reinterpret_cast(data_.begin()); }\n // Const Pointer to the beginning of the data block\n element_const_ptr_t element_wise_end() const {\n return reinterpret_cast(data_.end());\n }\n // Pointer to the beginning of the data block\n element_ptr_t element_wise_end() { return reinterpret_cast(data_.end()); }\n // The total number of elements in the tensor\n index_t num_elements() const { return offsets_[0] * dimensions_[0]; }\n // @deprecated\n int element_count() const { return num_elements(); }\n\n // Returns a non mutable reference pixel holder at the position `index`.\n element_const_ref_t operator[](index_t index) const { return this->element_wise_begin()[index]; }\n // Returns a mutable reference pixel holder at the position `index`.\n template \n std::enable_if_t operator[](index_t index) {\n return this->element_wise_begin()[index];\n }\n\n // const access to the underlying buffer object\n const buffer_t& data() const { return data_; }\n // access to the underlying buffer object\n template \n std::enable_if_t data() {\n return data_;\n }\n // The total numbe of bytes required to store the tensor\n size_t byte_size() const { return static_cast(element_count()) * sizeof(element_t); }\n\n private:\n // Returns true if all dimensions are greater than zero or zero\n static bool CheckDimensions(const dimensions_t& dimensions) {\n return (dimensions.array() >= 0).all();\n }\n\n // Sets the dimensions of the tensor and updates offsets.\n void setDimensions(const dimensions_t& dimensions) {\n dimensions_ = dimensions;\n offsets_[kRank - 1] = 1; // Rank is guaranteed to be positive\n for (int i = kRank - 1; i > 0; i--) {\n offsets_[i - 1] = offsets_[i] * dimensions_[i];\n }\n }\n\n // Computes the position of an element based on its coordinate.\n int indexToOffset(const coordinate_t& indices) const { return offsets_.dot(indices); }\n\n // storage for the tensor\n buffer_t data_;\n // The dimensions of the tensor.\n dimensions_t dimensions_;\n // Dimension offsets for indexing rows of storage\n dimensions_t offsets_;\n}; // namespace isaac\n\n// -------------------------------------------------------------------------------------------------\n\ntemplate \nusing CpuTensor = TensorBase, CpuBuffer>;\n\ntemplate \nusing CpuTensorView = TensorBase, CpuBufferView>;\n\ntemplate \nusing CpuTensorConstView = TensorBase, CpuBufferConstView>;\n\n#define ISAAC_DECLARE_CPU_TENSOR_TYPES_IMPL(N, T, S) \\\n using CpuTensor##N##S = CpuTensor; \\\n using CpuTensorView##N##S = CpuTensorView; \\\n using CpuTensorConstView##N##S = CpuTensorConstView;\n\n#define ISAAC_DECLARE_CPU_TENSOR_TYPES(N) \\\n template \\\n using CpuTensor##N = CpuTensor; \\\n template \\\n using CpuTensorView##N = CpuTensorView; \\\n template \\\n using CpuTensorConstView##N = CpuTensorConstView; \\\n ISAAC_DECLARE_CPU_TENSOR_TYPES_IMPL(N, uint8_t, ub) \\\n ISAAC_DECLARE_CPU_TENSOR_TYPES_IMPL(N, uint16_t, ui16) \\\n ISAAC_DECLARE_CPU_TENSOR_TYPES_IMPL(N, int, i) \\\n ISAAC_DECLARE_CPU_TENSOR_TYPES_IMPL(N, double, d) \\\n ISAAC_DECLARE_CPU_TENSOR_TYPES_IMPL(N, float, f)\n\nISAAC_DECLARE_CPU_TENSOR_TYPES(1)\nISAAC_DECLARE_CPU_TENSOR_TYPES(2)\nISAAC_DECLARE_CPU_TENSOR_TYPES(3)\nISAAC_DECLARE_CPU_TENSOR_TYPES(4)\n\n#undef ISAAC_DECLARE_CPU_TENSOR_TYPES\n#undef ISAAC_DECLARE_CPU_TENSOR_TYPES_IMPL\n\n// -------------------------------------------------------------------------------------------------\n\n// An Tensor stored in device memory which owns it's memory\ntemplate \nusing GpuTensor = TensorBase, CudaBuffer>;\n\n// A mutable view on an Tensor which is stored on GPU device memory, does not own memory, but can\n// be used to read and write the data of the underlying Tensor.\ntemplate \nusing GpuTensorView = TensorBase, CudaBufferView>;\n\n// A non-mutable view on an Tensor which is stored on GPU device memory, does not own its memory,\n// and can only be used to read the data of the underlying Tensor.\ntemplate \nusing GpuTensorConstView = TensorBase, CudaBufferConstView>;\n\n// Helper macro for ISAAC_DECLARE_CUDA_TENSOR_TYPES\n#define ISAAC_DECLARE_CUDA_TENSOR_TYPES_IMPL(N, K, S) \\\n using GpuTensor##N##S = GpuTensor; \\\n using GpuTensorView##N##S = GpuTensorView; \\\n using GpuTensorConstView##N##S = GpuTensorConstView;\n\n// Helper macro to define various GpuTensor types\n#define ISAAC_DECLARE_CUDA_TENSOR_TYPES(N) \\\n template \\\n using GpuTensor##N = GpuTensor; \\\n template \\\n using GpuTensorView##N = GpuTensorView; \\\n template \\\n using GpuTensorConstView##N = GpuTensorConstView; \\\n ISAAC_DECLARE_CUDA_TENSOR_TYPES_IMPL(N, uint8_t, ub) \\\n ISAAC_DECLARE_CUDA_TENSOR_TYPES_IMPL(N, uint16_t, ui16) \\\n ISAAC_DECLARE_CUDA_TENSOR_TYPES_IMPL(N, int, i) \\\n ISAAC_DECLARE_CUDA_TENSOR_TYPES_IMPL(N, double, d) \\\n ISAAC_DECLARE_CUDA_TENSOR_TYPES_IMPL(N, float, f)\n\nISAAC_DECLARE_CUDA_TENSOR_TYPES(1)\nISAAC_DECLARE_CUDA_TENSOR_TYPES(2)\nISAAC_DECLARE_CUDA_TENSOR_TYPES(3)\nISAAC_DECLARE_CUDA_TENSOR_TYPES(4)\n\n#undef ISAAC_DECLARE_CUDA_TENSOR_TYPES\n#undef ISAAC_DECLARE_CUDA_TENSOR_TYPES_IMPL\n\n// -------------------------------------------------------------------------------------------------\n\n// Creates a CpuTensorView instance from a raw host `data` pointer that allows to alter the data\n// pointed to, although it will still be owned by the entity that allocated it originally. The\n// `elements` parameter denotes the number of elements contained within `data`. The `shape`\n// parameter is a `Vector` with `N` being the tensor's rank. Its elements are the dimensions\n// of the tensor. The template parameters denote the variable type the CpuTensorView should\n// represent and the rank of the tensor.\ntemplate \nCpuTensorView CreateCpuTensorViewFromData(\n K* data, size_t elements, const Vector& shape) {\n return CpuTensorView(\n CpuBufferView(HostPointer(reinterpret_cast(data)), sizeof(K) * elements), shape);\n}\n\n// Creates a TensorConstView instance from a raw host `data` pointer. The data pointed to will still\n// be owned by the entity that allocated it originally. The `elements` parameter denotes the number\n// of elements contained within `data`. The `shape` parameter is a `Vector` with `N` being\n// the tensor's rank. Its elements are the dimensions of the tensor. The template parameters denote\n// the variable type the CpuTensorView should represent and the rank of the tensor.\ntemplate \nCpuTensorConstView CreateCpuTensorConstViewFromData(\n const K* data, size_t elements, const Vector& shape) {\n return CpuTensorConstView(\n CpuBufferConstView(\n HostPointer(reinterpret_cast(data)), sizeof(K) * elements),\n shape);\n}\n\n// Creates a GpuTensorView instance from a raw device `data` pointer that allows to alter the data\n// pointed to, although it will still be owned by the entity that allocated it originally. The\n// `elements` parameter denotes the number of elements contained within `data`. The `shape`\n// parameter is a `Vector` with `N` being the tensor's rank. Its elements are the dimensions\n// of the tensor. The template parameters denote the variable type the TensorView should represent\n// and the rank of the tensor.\ntemplate \nGpuTensorView CreateGpuTensorViewFromData(\n T* data, size_t elements, const Vector& shape) {\n return GpuTensorView(\n CudaBufferView(CudaPointer(reinterpret_cast(data)), sizeof(K) * elements),\n shape);\n}\n\n// Creates a GpuTensorConstView instance from a raw device `data` pointer. The data pointed to\n// will still be owned by the entity that allocated it originally.The `elements` parameter\n// denotes the number of elements contained within `data`. The `shape` parameter is a\n// `Vector` with `N` being the tensor's rank. Its elements are the dimensions of the\n// tensor. The template parameters denote the variable type the TensorView should represent and\n// the rank of the tensor.\ntemplate \nGpuTensorConstView CreateGpuTensorConstViewFromData(\n const T* data, size_t elements, const Vector& shape) {\n return GpuTensorConstView(\n CudaBufferConstView(\n CudaPointer(reinterpret_cast(data)), sizeof(K) * elements),\n shape);\n}\n\n// -------------------------------------------------------------------------------------------------\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/cuda_utils/launch_utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2019-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"cuda_runtime.h\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Computes a positive integer x such that (x - 1) * b < a <= x * b\ntemplate\nT DivRoundUp(T a, T b) {\n return (a + b - T{1}) / b;\n}\n\n// Same as DivRoundUp but for all three elements. This is for example useful in computing\n// launch parameters for CUDA kernels.\ninline dim3 DivRoundUp(dim3 a, dim3 b) {\n return {\n DivRoundUp(a.x, b.x),\n DivRoundUp(a.y, b.y),\n DivRoundUp(a.z, b.z)\n };\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/cuda_utils/stride_pointer.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2019-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"cuda_runtime.h\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// A CUDA-friendly pointer with a stride. Can be used to work with data which uses a grid layout\n// with a non non-trivial offset between rows. This means rows are longer than they would need to be\n// in order to enable higher performance.\ntemplate \nstruct StridePointer {\n // Pointer to the first element\n K* pointer;\n // Offset in bytes between consecutive rows.\n size_t stride;\n\n // Gets a pointer to the given row\n inline __host__ __device__\n K* row_pointer(int row) const {\n // TODO Properly cast pointer using reinterpret_cast with either char* or const char*\n return reinterpret_cast((char*)(pointer) + row * stride); // NOLINT\n }\n\n // Accesses the element at the coordinate (row, col)\n inline __host__ __device__\n const K& at(int row, int col) const { return row_pointer(row)[col]; }\n\n // Accesses the element at the coordinate (row, col)\n inline __host__ __device__\n K& at(int row, int col) { return row_pointer(row)[col]; }\n\n // Accesses the element at the given coordinates\n inline __host__ __device__\n const K& at(int2 coordinates) const { return at(coordinates.x, coordinates.y); }\n\n // Accesses the element at the given coordinates\n inline __host__ __device__\n K& at(int2 coordinates) { return at(coordinates.x, coordinates.y); }\n\n // Identical to `at`\n inline __host__ __device__\n const K& operator()(int row, int col) const { return row_pointer(row)[col]; }\n\n // Identical to `at`\n inline __host__ __device__\n K& operator()(int row, int col) { return row_pointer(row)[col]; }\n\n // Identical to `at`\n inline __host__ __device__\n const K& operator()(int2 coordinates) const { return at(coordinates.x, coordinates.y); }\n\n // Identical to `at`\n inline __host__ __device__\n K& operator()(int2 coordinates) { return at(coordinates.x, coordinates.y); }\n\n // Casts to a given element type. This can for example be used to cast between a\n // StridePointer used on the CPU and a StridePointer used on the GPU.\n template \n __host__ __device__\n StridePointer cast() const { return {reinterpret_cast(pointer), stride}; }\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/cuda_utils/stride_pointer_3d.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"cuda_runtime.h\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// TODO(kchinniah): move memory layout & shape defns inside StridePointer3D class\n\n// TODO(kpatzwaldt): merge all the multidimensional indexing methods (ISAFETY-1363)\n\n/// The memory layout of a 3D pointer\nenum class StridePointer3D_MemoryLayout {\n kNCHW, ///< batch_size x channel x height x width\n kHWC, ///< height x width x channel\n kNHWC, ///< batch_size x height x width x channel\n};\n\n/// The shape of a 3D pointer\nstruct StridePointer3D_Shape {\n /// The height\n uint32_t height{};\n /// The width\n uint32_t width{};\n /// The number of channels\n uint32_t channels{};\n};\n\n// A stride pointer that's suitable for indexing 3D data.\n// In particular, this is useful for processing tensors.\n// If no strides are specified, the strides are computed assuming no offsets / padding.\n// WARNING: the NCHW and NHWC drop the N (batch size) dimension, hence\n// assuming that the batch size is 1.\n// and are only included to make converting tensors easier.\n// Additionally, this pointer does not have ownership of the passed pointer\n// Access to this must be given as: (row, col, depth) or (height, width, channel)\n// Bound checking is responsible on the caller of the methods of this class\ntemplate \nclass StridePointer3D {\n private:\n /// The maximum allowable dimension\n static constexpr size_t kMaxDims{3};\n\n // Ensure that the received data has a size greater than 0\n static_assert(sizeof(T) > 0, \"Error: received type who's size is 0\");\n\n public:\n StridePointer3D() : memory_buffer_{nullptr}, shape_{}, memory_layout_{}, strides_{0, 0, 0} {}\n\n /**\n Creates a 3D Stride Pointer using the raw memory, shape and memory layout specified.\n\n This will compute trivial strides for the strides\n\n @param T The type of the memory buffer\n @param memory_buffer The memory buffer that will be traversed\n @param shape The shape of the memory buffer\n @param memory_layout The memory layout of the memory buffer\n **/\n StridePointer3D(\n T* memory_buffer, StridePointer3D_Shape shape, StridePointer3D_MemoryLayout memory_layout)\n : memory_buffer_{memory_buffer}, shape_{shape}, memory_layout_{memory_layout} {\n computeStrides();\n setStrideIndices();\n }\n\n /**\n Creates a 3D Stride Pointer using the raw memory, shape, memory layout and strides specified.\n\n The provided strides must be given in terms of bytes. These will be divided by sizeof(T) for\n indexing\n\n The byte_strides must be formatted as:\n - byte_strides[2] = The amount of bytes necessary to traverse one unit of the least significant\n dim\n - byte_strides[1] = The amount of bytes necessary to traverse one unit of the 2nd least\n significant dim\n - byte_strides[0] = The amount of bytes necessary to traverse one unit of the 3rd least\n significant dim\n\n For example, suppose the memory layout is MemoryLayout::kHWC and that there is no extra padding or\n offsets,\n - byte_strides[2] should be sizeof(T) since it requires sizeof(T) units to traverse along the\n channel axis\n - byte_strides[1] should be sizeof(T) * shape.channels since this is the amount of bytes required\n to traverse along the width axis\n - For example, if there are 3 channels and sizeof(T) = 1, then to go from width = 0 -> width = 1\n requires traversal of 3 units\n - byte_strides[0] should be sizeof(T) * shape.channels * shape.width since this is the amount of\n bytes required to traverse along the height axis\n - For example, if there are 3 channels, sizeof(T) = 1 and the width is 5, then to go from width\n = 0 -> 1 requires sizeof(T) * 3 channels, then since we would like to traverse from height 0 ->\n height 1, we must traverse 5 widths worth of memory, hence sizeof(T) * 3 channels * 5 width units\n is required\n\n @param T The type of the memory buffer\n @param memory_buffer The memory buffer that will be traversed\n @param shape The shape of the memory buffer\n @param memory_layout The memory layout of the memory buffer\n @param byte_strides The strides of each dimension in bytes\n **/\n StridePointer3D(\n T* memory_buffer, StridePointer3D_Shape shape, StridePointer3D_MemoryLayout memory_layout,\n const std::array& byte_strides)\n : memory_buffer_{memory_buffer}, shape_{shape}, memory_layout_{memory_layout} {\n for (size_t i = 0; i < kMaxDims; ++i) {\n strides_[i] = byte_strides[i] / sizeof(T);\n }\n setStrideIndices();\n }\n\n /**\n This is identical to the std::array version of the constructor\n **/\n StridePointer3D(\n T* memory_buffer, StridePointer3D_Shape shape, StridePointer3D_MemoryLayout memory_layout,\n size_t byte_strides[kMaxDims])\n : memory_buffer_{memory_buffer}, shape_{shape}, memory_layout_{memory_layout} {\n for (size_t i = 0; i < kMaxDims; ++i) {\n strides_[i] = byte_strides[i] / sizeof(T);\n }\n setStrideIndices();\n }\n\n /**\n Returns a mutable reference at the specified (row, col, depth).\n\n NOTE: (row, col, depth) corresponds to (height, width, channel) indexing\n\n WARNING: this method does not do bounds checking\n\n @param row The row (height) index\n @param col The column (width) index\n @param depth The depth (channel) index\n **/\n __device__ __host__ T& operator()(uint32_t row, uint32_t col, uint32_t depth) {\n return memory_buffer_[computeFlattenedIndex(row, col, depth)];\n }\n\n /**\n Returns a mutable reference at the specified (row, col). This assumes the depth is 0.\n\n This is useful for processing, grayscale images, for example\n\n NOTE: (row, col) corresponds to (height, width) indexing\n\n WARNING: this method does not do bounds checking\n\n @param row The row (height) index\n @param col The column (width) index\n **/\n __device__ __host__ T& operator()(uint32_t row, uint32_t col) {\n return memory_buffer_[computeFlattenedIndex(row, col, 0)];\n }\n\n /**\n Returns a constant reference at the specified (row, col, depth).\n\n NOTE: (row, col, depth) corresponds to (height, width, channel) indexing\n\n WARNING: this method does not do bounds checking\n\n @param row The row (height) index\n @param col The column (width) index\n @param depth The depth (channel) index\n **/\n __device__ __host__ const T& operator()(uint32_t row, uint32_t col, uint32_t depth) const {\n return memory_buffer_[computeFlattenedIndex(row, col, depth)];\n }\n\n /**\n Returns a constant reference at the specified (row, col). This assumes the depth is 0.\n\n This is useful for processing, grayscale images, for example\n\n WARNING: this method does not do bounds checking\n\n NOTE: (row, col) corresponds to (height, width) indexing\n\n @param row The row (height) index\n @param col The column (width) index\n **/\n __device__ __host__ const T& operator()(uint32_t row, uint32_t col) const {\n return memory_buffer_[computeFlattenedIndex(row, col, 0)];\n }\n\n /// Returns the memory layout\n __device__ __host__ StridePointer3D_MemoryLayout memory_layout() const { return memory_layout_; }\n\n /// Returns the shape\n __device__ __host__ StridePointer3D_Shape shape() const { return shape_; }\n\n /// Returns the memory buffer\n __device__ __host__ T* pointer() const { return memory_buffer_; }\n\n /**\n Returns the memory buffer at the specified (row, col, depth).\n\n NOTE: (row, col, depth) corresponds to (height, width, channel) indexing\n\n WARNING: this method does not do bounds checking\n\n @param row The row (height) index\n @param col The column (width) index\n @param depth The depth (channel) index\n **/\n __device__ __host__ T* pointerAt(uint32_t row, uint32_t col, uint32_t depth) const {\n return memory_buffer_ + computeFlattenedIndex(row, col, depth);\n }\n\n /**\n Returns the memory buffer at the specified (row, col). This assumes the depth is 0.\n\n This is useful for processing, grayscale images, for example\n\n NOTE: (row, col) corresponds to (height, width) indexing\n\n WARNING: this method does not do bounds checking\n\n @param row The row (height) index\n @param col The column (width) index\n **/\n __device__ __host__ T* pointerAt(uint32_t row, uint32_t col) const {\n return memory_buffer_ + computeFlattenedIndex(row, col, 0);\n }\n\n /**\n Returns the flattened index at the specified (row, col, depth).\n\n NOTE: (row, col, depth) corresponds to (height, width, channel) indexing\n\n @param row The row (height) index\n @param col The column (width) index\n @param depth The depth (channel) index\n **/\n __device__ __host__ size_t indexAt(uint32_t row, uint32_t col, uint32_t depth) const {\n return computeFlattenedIndex(row, col, depth);\n }\n\n /**\n Returns the flattened index at the specified (row, col). This assumes the depth is 0.\n\n This is useful for processing, grayscale images, for example\n\n NOTE: (row, col) corresponds to (height, width) indexing\n\n @param row The row (height) index\n @param col The column (width) index\n **/\n __device__ __host__ size_t indexAt(uint32_t row, uint32_t col) const {\n return computeFlattenedIndex(row, col, 0);\n }\n\n private:\n /// The raw memory buffer\n T* memory_buffer_{};\n\n /// The shape of the memory buffer\n StridePointer3D_Shape shape_{};\n\n /// The memory layout of the memory buffer\n StridePointer3D_MemoryLayout memory_layout_;\n\n /// The stride\n size_t strides_[kMaxDims];\n\n /// Maps a dimension to the stride array\n struct StrideIndexMapping {\n /// The height index mapping\n size_t height_idx{};\n\n /// The width index mapping\n size_t width_idx{};\n\n /// The channel index mapping\n size_t channel_idx{};\n } stride_index_mapping_;\n\n /**\n Computes the strides of the data based on the memory layout,\n assuming no extra memory offset or padding\n\n NOTE: the strides are divided by sizeof(T).\n This is why, for example, strides_[2] = 1\n\n The computed strides can be interpreted as follows:\n - strides_[2] -> the stride required to traverse along the least significant dimension\n - strides_[1] -> the stride required to traverse along the 2nd least significant dimension\n - strides_[0] -> the stride required to traverse along the 3rd least significant dimension\n **/\n void computeStrides() {\n switch (memory_layout_) {\n case StridePointer3D_MemoryLayout::kNHWC:\n case StridePointer3D_MemoryLayout::kHWC:\n strides_[2] = 1;\n strides_[1] = shape_.channels * strides_[2];\n strides_[0] = shape_.width * strides_[1];\n break;\n case StridePointer3D_MemoryLayout::kNCHW:\n strides_[2] = 1;\n strides_[1] = shape_.width * strides_[2];\n strides_[0] = shape_.height * strides_[1];\n break;\n }\n }\n\n /**\n Sets the index stride mapping based on the memory layout.\n\n For NHWC and HWC, this is height = 0, width = 1, channel = 2\n For NCHW, this is channel = 0, width = 1, height = 2\n **/\n void setStrideIndices() {\n switch (memory_layout_) {\n case StridePointer3D_MemoryLayout::kNHWC:\n case StridePointer3D_MemoryLayout::kHWC:\n stride_index_mapping_.height_idx = 0;\n stride_index_mapping_.width_idx = 1;\n stride_index_mapping_.channel_idx = 2;\n break;\n case StridePointer3D_MemoryLayout::kNCHW:\n stride_index_mapping_.channel_idx = 0;\n stride_index_mapping_.height_idx = 1;\n stride_index_mapping_.width_idx = 2;\n break;\n }\n }\n\n /**\n Flattens a 3 dimensional index into a 1 dimension one\n\n @param row The row (height) index\n @param col the col (width) index\n @param depth The depth (channel) index\n **/\n __device__ __host__ size_t\n computeFlattenedIndex(uint32_t row, uint32_t col, uint32_t depth) const {\n return row * strides_[stride_index_mapping_.height_idx] +\n col * strides_[stride_index_mapping_.width_idx] +\n depth * strides_[stride_index_mapping_.channel_idx];\n }\n};\n\n#define ISAAC_DECLARE_STRIDE_POINTER_3D_TYPES(T, S) using StridePointer3D##S = StridePointer3D;\n\nISAAC_DECLARE_STRIDE_POINTER_3D_TYPES(uint8_t, ub)\nISAAC_DECLARE_STRIDE_POINTER_3D_TYPES(uint16_t, ui16)\nISAAC_DECLARE_STRIDE_POINTER_3D_TYPES(int, i)\nISAAC_DECLARE_STRIDE_POINTER_3D_TYPES(double, d)\nISAAC_DECLARE_STRIDE_POINTER_3D_TYPES(float, f)\n\n#undef ISAAC_DECLARE_STRIDE_POINTER_3D_TYPES\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/cuda_utils/vector_math.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2019-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"cuda_runtime.h\"\n\nnamespace nvidia {\nnamespace isaac {\n\ninline __host__ __device__ float3 operator-(const float3& a, const float3& b) {\n return make_float3(a.x - b.x, a.y - b.y, a.z - b.z);\n}\n\ninline __host__ __device__ float2 operator-(const float2& a, const float2& b) {\n return make_float2(a.x - b.x, a.y - b.y);\n}\n\ninline __host__ __device__ float2 operator-(const float2& a, const int2& b) {\n return make_float2(a.x - static_cast(b.x), a.y - static_cast(b.y));\n}\n\ninline __host__ __device__ float2 operator-(const int2& a, const float2& b) {\n return make_float2(static_cast(a.x) - b.x, static_cast(a.y) - b.y);\n}\n\ninline __host__ __device__ int3 operator-(const int3& a, const int3& b) {\n return make_int3(a.x - b.x, a.y - b.y, a.z - b.z);\n}\n\ninline __host__ __device__ int2 operator-(const int2& a, const int2& b) {\n return make_int2(a.x - b.x, a.y - b.y);\n}\n\ninline __host__ __device__ float3 operator+(const float3& a, const float3& b) {\n return make_float3(a.x + b.x, a.y + b.y, a.z + b.z);\n}\n\ninline __host__ __device__ float2 operator+(const float2& a, const float2& b) {\n return make_float2(a.x + b.x, a.y + b.y);\n}\n\ninline __host__ __device__ int2 operator+(const int2& a, const int2& b) {\n return make_int2(a.x + b.x, a.y + b.y);\n}\n\ninline __host__ __device__ float3 operator*(const float3& a, const float& s) {\n return make_float3(s*a.x, s*a.y, s*a.z);\n}\n\ninline __host__ __device__ float3 operator*(const float& s, const float3& a) {\n return make_float3(s*a.x, s*a.y, s*a.z);\n}\n\ninline __host__ __device__ float2 operator*(const float2& a, const float& s) {\n return make_float2(s*a.x, s*a.y);\n}\n\ninline __host__ __device__ float2 operator*(const float& s, const float2& a) {\n return make_float2(s*a.x, s*a.y);\n}\n\n// Coeffient-wise multiplication for two 3-vectors\ninline __host__ __device__ float3 CwiseMult(const float3& a, const float3& b) {\n return make_float3(a.x*b.x, a.y*b.y, a.z*b.z);\n}\n\n// Dot product for two float3 vectors\ninline __host__ __device__ float Dot(const float3& a, const float3 b) {\n return a.x*b.x + a.y*b.y + a.z*b.z;\n}\n\n// Dot product for two float2 vectors\ninline __host__ __device__ float Dot(const float2& a, const float2 b) {\n return a.x*b.x + a.y*b.y;\n}\n\n// Dot product for two int3 vectors\ninline __host__ __device__ int Dot(const int3& a, const int3& b) {\n return a.x*b.x + a.y*b.y + a.z*b.z;\n}\n\n// Dot product for two int2 vectors\ninline __host__ __device__ int Dot(const int2& a, const int2& b) {\n return a.x*b.x + a.y*b.y;\n}\n\n// Cross product for two float3 vectors\ninline __host__ __device__ float3 Cross(const float3& a, const float3 b) {\n return make_float3(a.y * b.z - a.z * b.y,\n a.z * b.x - a.x * b.z,\n a.x * b.y - a.y * b.x);\n}\n\n// Square of 2-norm for a float3 vector\ninline __host__ __device__ float SquareNorm(const float3& a) {\n return Dot(a, a);\n}\n\n// Square of 2-norm for a int3 vector\ninline __host__ __device__ int SquareNorm(const int3& a) {\n return Dot(a, a);\n}\n\n// Square of 2-norm for a float2 vector\ninline __host__ __device__ float SquareNorm(const float2& a) {\n return Dot(a, a);\n}\n\n// 2-norm for a float3 vector\ninline __host__ __device__ float Norm(const float3& a) {\n return sqrtf(SquareNorm(a));\n}\n\n// 2-norm for a float2 vector\ninline __host__ __device__ float Norm(const float2& a) {\n return sqrtf(SquareNorm(a));\n}\n\n// Coefficient-wise sum for a float3 vector\ninline __host__ __device__ float Sum(const float3& a) {\n return a.x + a.y + a.z;\n}\n\ninline __host__ __device__ int2 Floorf(const float2& a) {\n return make_int2(floorf(a.x), floorf(a.y));\n}\n\n// Coefficient-wise conversion to int for a uchar3 vector\ninline __host__ __device__ int3 ToInt(uchar3 a) {\n return make_int3(static_cast(a.x), static_cast(a.y), static_cast(a.z));\n}\n\n// Coefficient-wise conversion to float for a int3 vector\ninline __host__ __device__ float3 ToFloat(int3 a) {\n return make_float3(static_cast(a.x), static_cast(a.y), static_cast(a.z));\n}\n\n// Coefficient-wise conversion to float for a int2 vector\ninline __host__ __device__ float2 ToFloat(int2 a) {\n return make_float2(static_cast(a.x), static_cast(a.y));\n}\n\n// Accesses the index-th element of a float4 vector. Assumes index = 0 if index not in {0, 1, 2, 3}.\ninline __device__ float& Coefficient(float4& a, int index) {\n if (index == 0) return a.x;\n else if (index == 1) return a.y;\n else if (index == 2) return a.z;\n else if (index == 3) return a.w;\n else return a.x; // NOLINT\n}\n\n// Accesses the index-th element of a short4 vector. Assumes index = 0 if index not in {0, 1, 2, 3}.\ninline __device__ short& Coefficient(short4& a, int index) { // NOLINT\n if (index == 0) return a.x;\n else if (index == 1) return a.y;\n else if (index == 2) return a.z;\n else if (index == 3) return a.w;\n else return a.x; // NOLINT\n}\n\n// Rotate a float2 unit vector by another float2 vector. The vector elements represent the cos and\n// sin of the rotation angle of the vector.\ninline __host__ __device__ float2 Rotate(const float2& a, const float2& b) {\n return make_float2(a.x * b.x - a.y * b.y, a.y * b.x + a.x * b.y);\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/flatscan/flatscan_info.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\nnamespace nvidia {\nnamespace isaac {\n\n// Data structure holding meta information about flatscan messages. Every flatscan message must\n// contain an instance of this message.\nstruct FlatscanInfo {\n // If the beam free range end is greater than or equal to this value the beam did not hit an\n // obstacle at the end of the free range.\n double out_of_range;\n // Horizontal width of every beam in radians.\n double beam_width;\n // The lower z value of the height slice.\n double height_min;\n // The upper z value of the height slice.\n double height_max;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/flatscan/flatscan_types.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/composite/composite_view.hpp\"\n#include \"gems/composite/schema.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Describes each beam in a flatscan\nstruct FlatscanIndices {\n enum {\n // Angle of the beam\n kAngle,\n // Start of the free range\n kRangeStart,\n // End of the free range\n kRangeEnd,\n // Visibility range of the flat ray, e.g., the furthest distance the ray could reach within\n // the height slice without any obstacles\n kVisibilityRange,\n // The relative time for this beam to the message timestamp, unit in seconds\n // beam_absolute_time = message_time + relative_time\n kRelativeTime,\n kSize\n };\n};\n\ninline composite::Schema FlatscanCompositeSchema() {\n return composite::Schema({\n composite::Quantity::Scalar(\"angle\", composite::Measure::kRotation),\n composite::Quantity::Scalar(\"range_start\", composite::Measure::kPosition),\n composite::Quantity::Scalar(\"range_end\", composite::Measure::kPosition),\n composite::Quantity::Scalar(\"visibility_range\", composite::Measure::kPosition),\n composite::Quantity::Scalar(\"relative_time\", composite::Measure::kTime),\n });\n}\n\ntemplate \nstruct FlatscanImmutableInterface : public Base {\n using Base::Base;\n using Base::operator=;\n\n K angle() const { return get(*this); }\n K range_start() const { return get(*this); }\n K range_end() const { return get(*this); }\n K visibility_range() const { return get(*this); }\n K relative_time() const { return get(*this); }\n};\n\ntemplate \nstruct FlatscanMutableInterface : public FlatscanImmutableInterface {\n using FlatscanImmutableInterface::FlatscanImmutableInterface;\n using FlatscanImmutableInterface::operator=;\n\n K& angle() { return get(*this); }\n K& range_start() { return get(*this); }\n K& range_end() { return get(*this); }\n K& visibility_range() { return get(*this); }\n K& relative_time() { return get(*this); }\n};\n\ntemplate \nusing FlatscanConstView = CompositeConstView;\n\ntemplate \nusing FlatscanView = CompositeView;\n\ntemplate \nusing Flatscan = Composite;\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/line.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/math/utils.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// Represent a line in dimension N.\n// The line is defined with a point and a ray. If IsFullLine is set to false then the line is a\n// half line starting from the origin and in the direction of the ray.\ntemplate \nclass Line {\n public:\n // Type of a point.\n using Vector_t = Vector;\n using Scalar = K;\n constexpr static int kDimension = N;\n\n // Empty constructor to allow allocation\n Line() {}\n\n // Helper to create a direction from a point and a direction.\n static Line FromDirection(const Vector_t& pt, const Vector_t& direction) {\n return Line{pt, direction};\n }\n // Helper to create a direction from two points.\n static Line FromPoints(const Vector_t& a, const Vector_t& b) {\n return Line{a, b-a};\n }\n\n // Returns a point on the line.\n const Vector_t& origin() const {\n return origin_;\n }\n\n // Returns the direction starting from the extremity 'origin'.\n const Vector_t& direction() const {\n return direction_;\n }\n\n // Clamp the value of lambda such as origin() + lambda * direction() belong on the Line.\n K clamp(K lambda) const {\n if (IsFullLine) {\n return lambda;\n } else {\n return std::max(K(0), lambda);\n }\n }\n\n // Casts to a different type\n template ::value, int> = 0>\n Line cast() const {\n return Line::FromDirection(\n origin_.template cast(), direction_.template cast());\n }\n template::value, int> = 0>\n const Line& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n\n private:\n // Private constructor to avoid confusion between direction initialization and points\n // initialization. Use FromDirection or FromPoints to create a line.\n Line(const Vector_t& origin, const Vector_t& direction) : origin_(origin), direction_(direction) {\n ASSERT(!IsAlmostZero(direction.squaredNorm()), \"direction must not be null\");\n }\n\n Vector_t origin_;\n Vector_t direction_;\n};\n\nusing Line2d = Line;\nusing Line3d = Line;\nusing Line4d = Line;\nusing Line2f = Line;\nusing Line3f = Line;\nusing Line4f = Line;\n\nusing Ray2d = Line;\nusing Ray3d = Line;\nusing Ray4d = Line;\nusing Ray2f = Line;\nusing Ray3f = Line;\nusing Ray4f = Line;\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/line_segment.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/math/utils.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// Represent a segment in dimension N.\n// The segment is defined with a couple of points (both extremities).\ntemplate \nclass LineSegment {\n public:\n // Type of a point.\n using Vector_t = Vector;\n using Scalar = K;\n constexpr static int kDimension = N;\n\n // Empty constructor to allow allocation.\n LineSegment() {}\n\n // Constructor.\n LineSegment(const Vector_t& a, const Vector_t& b) : a_(a), b_(b) {\n }\n\n // Helper to create a segment from two points.\n static LineSegment FromPoints(const Vector_t& a, const Vector_t& b) {\n return LineSegment{a, b};\n }\n\n // Returns one extremity such as origin() + direction() == the other extremity.\n const Vector_t& origin() const {\n return a_;\n }\n\n // Returns the direction starting from the extremity 'origin'.\n const Vector_t direction() const {\n return b_ - a_;\n }\n\n // Returns one extremity of the segment.\n const Vector_t& a() const {\n return a_;\n }\n\n // Returns one extremity of the segment.\n Vector_t& a() {\n return a_;\n }\n\n // Returns the other extremity of the segment.\n const Vector_t& b() const {\n return b_;\n }\n\n // Returns the other extremity of the segment.\n Vector_t& b() {\n return b_;\n }\n\n // Clamp the value of lambda such as origin() + lambda * direction() belong on the LineSegment.\n K clamp(K lambda) const {\n return lambda <= K(0) ? K(0) : (lambda < K(1) ? lambda : K(1));\n }\n\n // Casts to a different type\n template ::value, int> = 0>\n LineSegment cast() const {\n return LineSegment(a_.template cast(), b_.template cast());\n }\n template::value, int> = 0>\n const LineSegment& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n\n private:\n Vector_t a_;\n Vector_t b_;\n};\n\nusing LineSegment2i = LineSegment;\nusing LineSegment3i = LineSegment;\nusing LineSegment4i = LineSegment;\nusing LineSegment2d = LineSegment;\nusing LineSegment3d = LineSegment;\nusing LineSegment4d = LineSegment;\nusing LineSegment2f = LineSegment;\nusing LineSegment3f = LineSegment;\nusing LineSegment4f = LineSegment;\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/line_utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/core/assert.hpp\"\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/math/utils.hpp\"\n#include \"gems/geometry/polyline.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// Returns the closest point of a segment (ab) to a point `p`.\n// NOTE: It can be used with Line/HalfLine/Segment.\ntemplate\ntypename Line::Vector_t ClosestPointToLine(const Line& line, const typename Line::Vector_t& p);\n\n// Returns the squared distance between a point and a Line/HalfLine/Segment.\n// Avoid any sqrt by using the pytagorian theorem.\ntemplate\ntypename Line::Scalar SquaredDistancePointToLine(const Line& line,\n const typename Line::Vector_t& p);\n\n// Returns the distance between a point and a Line/HalfLine/Segment.\ntemplate\ntypename Line::Scalar DistancePointToLine(const Line& line, const typename Line::Vector_t& p);\n\n// Returns whether two Line/HalfLine/Segment are intersecting.\n// In addition if the line intersect lambda_{A/B} would be filled such as:\n// A.origin() + lambda_a A.direction() == B.origin() + lambda_b B.direction()\ntemplate\nbool AreLinesIntersecting(const LineT1& line_a, const LineT2& line_b,\n typename LineT1::Scalar* lambda_a = nullptr,\n typename LineT1::Scalar* lambda_b = nullptr);\n\n// Returns the closest point of two lines. If the lines are intersecting, the intersection will be\n// returned, otherwise (i.e. when the lines are parallel), any point of any line would work. Note\n// that if a line segment is passed this function only looks at the underlying line and ignores the\n// start and end of the segment.\ntemplate \nVector2 Intersection(const LineT1& line_a, const LineT2& line_b);\n\n// Returns the closest point of a segment [ab] to a point `p`.\ntemplate\nVector ClosestPointToSegment(const Vector& a, const Vector& b,\n const Vector& p);\n\n// Returns the closest point of a polyline [ab...yz] to a point `p`.\n// If `segment_index` is provided, it will contain the index of the segment the closest to the\n// point.\ntemplate\nVector ClosestPointToPolyline(const Polyline& polyline, const Vector& p,\n size_t* segment_index = nullptr);\n\n// Returns the squared distance of a point `p` to a segment [ab].\ntemplate\nK DistanceSquaredPointToSegment(const Vector& a, const Vector& b,\n const Vector& p);\n\n// Returns the distance of a point `p` to a segment [ab].\ntemplate\nK DistancePointToSegment(const Vector& a, const Vector& b, const Vector& p);\n\n// -------------------------------------------------------------------------------------------------\n\ntemplate\ntypename Line::Vector_t ClosestPointToLine(const Line& line, const typename Line::Vector_t& p) {\n const typename Line::Vector_t& ray = line.direction();\n const typename Line::Vector_t ap = p - line.origin();\n const typename Line::Scalar l = line.clamp(ray.dot(ap) / ray.squaredNorm());\n return line.origin() + l * ray;\n}\n\ntemplate\ntypename Line::Scalar SquaredDistancePointToLine(const Line& line,\n const typename Line::Vector_t& p) {\n using K = typename Line::Scalar;\n const typename Line::Vector_t& ray = line.direction();\n const typename Line::Vector_t ap = p - line.origin();\n const K ray_sq_norm = ray.squaredNorm();\n // Check this is not an empty segment, in which case the distance is the distance to one of the\n // extremities.\n if (IsAlmostZero(ray_sq_norm)) return ap.squaredNorm();\n const K dot = ray.dot(ap);\n const K l = dot / ray_sq_norm;\n const K cl = line.clamp(l);\n const K cl2 = cl * cl * ray_sq_norm;\n return ap.squaredNorm() + cl2 - K(2) * l * cl * ray_sq_norm;\n}\n\ntemplate\ntypename Line::Scalar DistancePointToLine(const Line& line, const typename Line::Vector_t& p) {\n return std::sqrt(SquaredDistancePointToLine(line, p));\n}\n\n// P(x, y) is on a line iff (P-A)xR_a = 0\n// We are looking for lambda such as (B + lambda R_b - A) x R_a = 0\n// lambda = (A-B) x R_a / (R_b x R_a)\n// x denotes the cross product here.\ntemplate\nbool AreLinesIntersecting(const LineT1& line_a, const LineT2& line_b,\n typename LineT1::Scalar* lambda_a,\n typename LineT1::Scalar* lambda_b) {\n static_assert(LineT1::kDimension == 2 && LineT2::kDimension == 2,\n \"AreLinesIntersecting only works in 2D\");\n static_assert(std::is_same::value,\n \"Type mismatch\");\n using K = typename LineT1::Scalar;\n K lA, lB;\n if (lambda_a == nullptr) lambda_a = &lA;\n if (lambda_b == nullptr) lambda_b = &lB;\n const Vector2& R_a = line_a.direction();\n const Vector2& R_b = line_b.direction();\n const K ray_cross = CrossProduct(R_b, R_a);\n // The two lines are parallel, they could still intersect in one or an infinity of points.\n if (IsAlmostZero(ray_cross)) {\n const Vector2 pt = ClosestPointToLine(line_a, line_b.origin());\n constexpr K kEpsilonThreshold = MachineEpsilon * 1000.0;\n if (SquaredDistancePointToLine(line_b, pt) >= kEpsilonThreshold) return false;\n const K R_a_norm = line_a.direction().squaredNorm();\n const K R_b_norm = line_b.direction().squaredNorm();\n *lambda_a = IsAlmostZero(R_a_norm) ? K(0) : (pt - line_a.origin()).dot(R_a) / R_a_norm;\n *lambda_b = IsAlmostZero(R_b_norm) ? K(0) : (pt - line_b.origin()).dot(R_b) / R_b_norm;\n } else {\n const Vector2 BA = line_a.origin() - line_b.origin();\n *lambda_b = CrossProduct(BA, R_a) / ray_cross;\n *lambda_a = CrossProduct(BA, R_b) / ray_cross;\n }\n // Checks that both lambda is within the range of the line.\n return line_a.clamp(*lambda_a) == *lambda_a && line_b.clamp(*lambda_b) == *lambda_b;\n}\n\ntemplate\nVector2 Intersection(const LineT1& line_a, const LineT2& line_b) {\n static_assert(std::is_same(),\n \"both line need to have the same type\");\n using K = typename LineT1::Scalar;\n // Line equation is given by:\n // line.direction.tangent.dot(x, y) = line.direction.tangent.dot(line.origin)\n // We have a set of two equations, with two unknowns:\n // ( d1_y -d1_x) (x) (a)\n // ( ) * ( ) = ( )\n // (-d2_y d2_x) (y) (b)\n const Vector2 t1(line_a.direction().y(), -line_a.direction().x());\n const Vector2 t2(-line_b.direction().y(), line_b.direction().x());\n const K det = t1.dot(line_b.direction());\n // In this case the line are parallel.\n if (IsAlmostZero(det)) return line_a.origin();\n\n Matrix2 matrix_inverse;\n matrix_inverse << t2.y(), -t1.y(), -t2.x(), t1.x();\n const Vector2 result(line_a.origin().dot(t1), line_b.origin().dot(t2));\n return matrix_inverse * result / det;\n}\n\ntemplate\nVector ClosestPointToSegment(const Vector& a, const Vector& b,\n const Vector& p) {\n const Vector ab = b - a;\n const Vector ap = p - a;\n const K l = ab.dot(ap);\n if (l <= K(0)) {\n return a;\n }\n const K ab_n2 = ab.squaredNorm();\n if (l >= ab_n2) {\n return b;\n }\n return a + (l / ab_n2) * ab;\n}\n\ntemplate\nVector ClosestPointToPolyline(const Polyline& polyline, const Vector& p,\n size_t* segment_index) {\n ASSERT(polyline.size() > 0, \"Polyline is empty\");\n if (segment_index) *segment_index = 0;\n K best_dist = (p - polyline.front()).squaredNorm();\n Vector ret = polyline.front();\n for (size_t i = 1; i < polyline.size(); i++) {\n const auto vec = ClosestPointToSegment(polyline[i - 1], polyline[i], p);\n const K dist = (vec - p).squaredNorm();\n if (dist < best_dist) {\n best_dist = dist;\n ret = vec;\n if (segment_index) *segment_index = i-1;\n }\n }\n return ret;\n}\n\ntemplate\nK DistanceSquaredPointToSegment(const Vector& a, const Vector& b,\n const Vector& p) {\n const Vector ab = b - a;\n const Vector ap = p - a;\n const K l = ab.dot(ap);\n if (l <= K(0)) {\n return ap.squaredNorm();\n }\n const K ab_n2 = ab.squaredNorm();\n if (l >= ab_n2) {\n return (b - p).squaredNorm();\n }\n return ap.squaredNorm() - l * l / ab_n2;\n}\n\ntemplate\nK DistancePointToSegment(const Vector& a, const Vector& b, const Vector& p) {\n return std::sqrt(DistanceSquaredPointToSegment(a, b, p));\n}\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/n_cuboid.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// Represent a Rectangular Cuboid in dimension N (https://en.wikipedia.org/wiki/Cuboid).\ntemplate \nclass NCuboid {\n public:\n // Type of a point.\n using Vector_t = Vector;\n using Scalar = K;\n constexpr static int kDimension = N;\n\n // Creates a NCuboid from the boundaries:\n // A point will belong in the cuboid if for each dimension dims[i][0] <= pt[i] <= dims[i][1].\n static NCuboid FromBoundingCuboid(const std::array, N>& dims) {\n Vector_t min, max;\n for (size_t dim = 0; dim < N; dim++) {\n min[dim] = dims[dim][0];\n max[dim] = dims[dim][1];\n }\n return NCuboid{min, max};\n }\n\n // Creates a NCuboid from the boundaries:\n // A point will belong in the cuboid if for each dimension min[i] <= pt[i] <= max[i].\n static NCuboid FromOppositeCorners(const Vector_t& corner1, const Vector_t& corner2) {\n return NCuboid{corner1, corner2};\n }\n\n // Creates a NCuboid from the center and the size of each dimensions.\n // A point will belong in the cuboid if for each dimension:\n // center[i] - sizes[i]/2 <= pt[i] <= center[i] + sizes[i]/2\n static NCuboid FromSizes(const Vector_t& center, const Vector_t& sizes) {\n const Vector_t min = center - sizes / K(2);\n return NCuboid{min, (min + sizes).eval()};\n }\n\n // Empty constructor to allow allocation\n NCuboid() {}\n\n // Accessor\n const Vector_t& min() const { return min_; }\n Vector_t& min() { return min_; }\n const Vector_t& max() const { return max_; }\n Vector_t& max() { return max_; }\n\n // Returns the center point of the cuboid\n Vector_t center() const { return (min_ + max_) / K(2); }\n\n // Returns sizes of each dimension of the cuboid\n Vector_t sizes() const { return max_ - min_; }\n\n // Returns whether a point is inside the cuboid\n bool isInside(const Vector_t& pt) const {\n for (size_t dim = 0; dim < kDimension; dim++) {\n if (pt[dim] < min_[dim] || pt[dim] > max_[dim]) {\n return false;\n }\n }\n return true;\n }\n\n // Casts to a different type\n template ::value, int> = 0>\n NCuboid cast() const {\n return NCuboid::FromOppositeCorners(min_.template cast(), max_.template cast());\n }\n template ::value, int> = 0>\n const NCuboid& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n\n // Computes Volume of cuboid. Computes the area if N is 2.\n Scalar volume() const {\n Scalar volume = Scalar(1);\n for (size_t dim = 0; dim < kDimension; dim++) {\n volume *= max_[dim] - min_[dim];\n }\n return volume;\n }\n\n // Extends this n_cuboid to contain the other n_cuboid\n void encapsulate(const NCuboid& other) {\n min_ = min_.cwiseMin(other.min());\n max_ = max_.cwiseMax(other.max());\n }\n\n // Extends this n_cuboid to contain point\n void encapsulate(const Vector_t& point) {\n min_ = min_.cwiseMin(point);\n max_ = max_.cwiseMax(point);\n }\n\n // Translates the box\n void translate(const Vector_t& translation) {\n min_ += translation;\n max_ += translation;\n }\n\n private:\n // Private constructor to avoid confusion between corners initialization and sizes initialization.\n // Use FromOppositeCorners or FromSizes to create a line.\n NCuboid(const Vector_t& corner1, const Vector_t& corner2) {\n for (size_t dim = 0; dim < kDimension; dim++) {\n if (corner1[dim] < corner2[dim]) {\n min_[dim] = corner1[dim];\n max_[dim] = corner2[dim];\n } else {\n min_[dim] = corner2[dim];\n max_[dim] = corner1[dim];\n }\n }\n }\n Vector_t min_, max_;\n};\n\ntemplate \nusing Rectangle = NCuboid;\ntemplate \nusing Box = NCuboid;\n\nusing RectangleD = Rectangle;\nusing RectangleF = Rectangle;\nusing RectangleI = Rectangle;\nusing BoxD = Box;\nusing BoxF = Box;\nusing BoxI = Box;\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/n_sphere.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// Represent a sphere in dimension N.\n// Note: the mathematical definition of N-Sphere belongs in a space at N+1 dimensions. The N\n// provided as template argument corresponds to the number of dimension.\n// Therefore a circle is 1-sphere mathematically but NSphere here.\n// Same for the regular sphere: 2-sphere mathematically but NSphere here.\ntemplate \nstruct NSphere {\n public:\n // Type of a point.\n using Vector_t = Vector;\n using Scalar = K;\n constexpr static int kDimension = N;\n\n Vector_t center;\n Scalar radius;\n\n // Returns whether a point is inside the sphere\n bool isInside(const Vector_t& pt) const {\n return (center - pt).squaredNorm() <= radius * radius;\n }\n\n // Casts to a different type\n template ::value, int> = 0>\n NSphere cast() const {\n return NSphere{center.template cast(), static_cast(radius)};\n }\n template::value, int> = 0>\n const NSphere& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n};\n\ntemplate \nusing Circle = NSphere;\ntemplate \nusing Sphere = NSphere;\n\nusing CircleD = Circle;\nusing CircleF = Circle;\nusing SphereD = Sphere;\nusing SphereF = Sphere;\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/pinhole.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/assert.hpp\"\n#include \"gems/core/epsilon.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// A pinhole camera model describes how points in 3D space are projected onto a 2D image plane.\n//\n// In Isaac we choose the following coordinate frames:\n// * Camera coordinate, i.e. a point in front of the pinhole which will be projected onto the\n// image plane, are given as:\n// X right, Y down, Z forward.\n// * Image coordinates, i.e. a point in pixel coordinates, are given as:\n// 0: rows, 1: columns\n//\n// The pinhole type is templated on the scalar type used for optical center and focal length.\n// This type must be a floating point type like float or double.\ntemplate ::value, int>::type = 0>\nstruct Pinhole {\n // The dimensions of the camera image plane in pixels in the order (rows, columns)\n Vector2i dimensions;\n // Focal length of the projection (in pixels) in the order (row, column)\n Vector2 focal;\n // Optical center of the projection (in pixels) in the order (row, column)\n Vector2 center;\n\n // Creates a pinhole camera model from horizontal field of view with center in the middle or the\n // image plane.\n static Pinhole FromHorizontalFieldOfView(const Vector2i& dimensions, K fov_horizontal) {\n ASSERT(fov_horizontal > K(0), \"Field of view must be greater than 0\");\n const K focal = static_cast(dimensions[1]) / (K(2) * std::tan(K(0.5) * fov_horizontal));\n return Pinhole{dimensions, {focal, focal}, K(0.5) * dimensions.cast()};\n }\n static Pinhole FromHorizontalFieldOfView(int rows, int cols, K fov_horizontal) {\n return FromHorizontalFieldOfView({rows, cols}, fov_horizontal);\n }\n // Similar to `FromHorizontalFieldOfView`, but the field of view angle indicates the vertical\n // field of view.\n static Pinhole FromVerticalFieldOfView(const Vector2i& dimensions, K fov_vertical) {\n ASSERT(fov_vertical > K(0), \"Field of view must be greater than 0\");\n const K focal = static_cast(dimensions[0]) / (K(2) * std::tan(K(0.5) * fov_vertical));\n return Pinhole{dimensions, {focal, focal}, K(0.5) * dimensions.cast()};\n }\n static Pinhole FromVerticalFieldOfView(int rows, int cols, K fov_vertical) {\n return FromVerticalFieldOfView({rows, cols}, fov_vertical);\n }\n\n // Projects a 3D point in camera coordinates onto the pixel plane and returns the pixel coordinate\n // as fractional values.\n template ::value, int>::type = 0>\n Vector2 project(const Eigen::MatrixBase& point) const {\n ASSERT(!IsAlmostZero(point[2]), \"Invaid point with z almost 0 (%f)\", point[2]);\n return ((point.template head<2>() / point[2]).array()).reverse() * focal.array() +\n center.array();\n }\n // Projects a 3D point in camera coordinates onto the pixel plane and rouns the pixel coordinate\n // to the nearest pixel on the image plane (rounding down).\n template ::value, int>::type = 0>\n Vector2i projectToInt(const Eigen::MatrixBase& point) const {\n const Vector2 pixel = project(point);\n return {FloorToInt(pixel[0]), FloorToInt(pixel[1])};\n }\n\n // Casts a ray through the given pixel coordinate and gives the point on the ray at the given\n // distance `depth`. The point is given in camera coordinates.\n template ::value, int>::type = 0>\n Vector3 unproject(const Eigen::MatrixBase& pixel, K depth) const {\n const Vector2 a = ((pixel - center).array() / focal.array()) * depth;\n return {a[1], a[0], depth};\n }\n // Special version for integer-coordinate pixels. We assume that pixel rays go through the center\n // of the pixel.\n template <\n typename Derived,\n typename std::enable_if::value, int>::type = 0>\n Vector3 unproject(const Eigen::MatrixBase& pixel, K depth) const {\n return unproject(pixel.template cast() + Vector2{K(0.5), K(0.5)}, depth);\n }\n Vector3 unproject(int px, int py, K depth) const {\n return unproject(Vector2i{px, py}.template cast() + Vector2{K(0.5), K(0.5)}, depth);\n }\n\n // Computes the area of a pixel at given depth assuming a planar patch\n K pixelAreaAtDepth(K depth) const { return depth * depth / (focal[0] * focal[1]); }\n\n // Scale the pinhole. The scale factor is different for rows and cols\n Pinhole scale(const Vector2& scale_factor) const {\n ASSERT((scale_factor.array() >= 0).all(), \"Invalid scale factor\");\n return { (dimensions.template cast().cwiseProduct(scale_factor)).template cast(),\n focal.cwiseProduct(scale_factor),\n center.cwiseProduct(scale_factor)};\n }\n\n // Scale the pinhole\n Pinhole scale(K scale_factor) const {\n ASSERT(scale_factor > K(0), \"Invalid scale factor\");\n return scale(Vector2{scale_factor, scale_factor});\n }\n\n // First crop the intrinsics and then scale them\n Pinhole cropAndScale(const Vector2i& crop_start, const Vector2i& crop_size,\n const Vector2i& scaled_size) const {\n ASSERT((crop_start.array() >= 0).all(), \"Invalid crop start\");\n ASSERT((crop_start.array() < dimensions.array()).all(), \"Invalid crop start\");\n ASSERT((crop_size.array() > 0).all(), \"Invalid crop size\");\n const Pinhole cropped_pinhole{crop_size, focal, center - crop_start.cast()};\n return cropped_pinhole.scale(scaled_size.cast().cwiseQuotient(crop_size.cast()));\n }\n\n // Computes the field of view angles (in radians) in the order (vertical, horizontal)\n Vector2 computeFieldOfView() const {\n return { K(2) * std::atan2(K(0.5) * static_cast(dimensions[0] - 1), focal[0]),\n K(2) * std::atan2(K(0.5) * static_cast(dimensions[1] - 1), focal[1]) };\n }\n\n // Returns the 3x3 projection matrix\n Matrix3 matrix() const {\n Matrix3 mat;\n mat << K(0), focal[0], center[0], focal[1], K(0), center[1], K(0), K(0), K(1);\n return mat;\n }\n\n // Casts the pinhole to a different numeric type. For example from double to float.\n template \n Pinhole cast() const {\n return {dimensions, focal.template cast(), center.template cast()};\n }\n};\n\n// Typedef for pinhole with using 64-bit floating points\nusing PinholeD = Pinhole;\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/plane.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"Eigen/Eigen\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// A plane in N dimensions represented by a normal vector and an offset.\ntemplate\nusing Hyperplane = class Eigen::Hyperplane;\n\ntemplate\nusing Plane = Hyperplane;\nusing PlaneF = Plane;\nusing PlaneD = Plane;\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/polygon.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gems/core/math/types.hpp\"\n#include \"gems/geometry/line_segment.hpp\"\n#include \"gems/geometry/line_utils.hpp\"\n#include \"gems/geometry/n_cuboid.hpp\"\n#include \"gems/geometry/n_sphere.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// A polygon in 2D, the last point and first point are connected\ntemplate \nstruct Polygon2 {\n // Type of a point.\n using Vector_t = Vector2;\n using Scalar = K;\n\n std::vector points;\n\n // Returns whether a point is inside the polygon\n // Note that this method is not accurate if the point lies too close to one edge, Especially if\n // the point is really close to the edge or of a vertex, it might return true.\n // This function used the strategy of counting the intersection between the segments of the\n // polygon and a virtual segment from the `pt` to a point outside of the polygon. While fast, this\n // method does not work well when the virtual segment is too close to one of the vertices. In this\n // case it fallbacks to the slower implementation below.\n bool isInside(const Vector_t& pt) const {\n if (points.empty()) return false;\n // Select a point outside of the polygon (max(x) + 1, max(y) + 2).\n // Picking a different constant for x and y helps reduce the chance the point is aligned with\n // one vertex.\n Vector_t max = points.front();\n for (const auto& point : points) {\n max.x() = std::max(max.x(), point.x() + K(1));\n max.y() = std::max(max.y(), point.y() + K(2));\n }\n // If the maximum value of x+1 is less or equal to our point, then we are obviously outside.\n if (max.x() <= pt.x()) return false;\n if (max.y() <= pt.y()) return false;\n const LineSegment seg(pt, max);\n // Count how many segment it intersects, if it's an odd number then the point is inside or on\n // one edge.\n int counter = 0;\n for (size_t ix = 0; ix < points.size(); ix++) {\n const LineSegment edge(points[ix], points[(ix + 1) % points.size()]);\n K lambda;\n if (AreLinesIntersecting(seg, edge, nullptr, &lambda)) {\n counter++;\n // If our lines are too close, we fallback to the slow but accurate method.\n if (IsAlmostZero(lambda) || IsAlmostOne(lambda)) {\n return slowIsInside(pt);\n }\n }\n }\n return counter % 2 == 1;\n }\n\n // Returns whether a point is inside the polygon\n // This function is a bit slow and should not be called in critical path too often.\n // This function used the strategy to measure the sum of the field of view the segment are\n // observed. It was the most accurate solution, however it requires using trigonometric functions,\n // which are quite slow.\n bool slowIsInside(const Vector_t& pt) const {\n if (points.empty()) return false;\n K sum_angle = K(0);\n Vector_t delta = points.back() - pt;\n // If delta == 0, it means pt is the same as one of the vertex.\n if (IsAlmostZero(delta.squaredNorm())) return true;\n K last_angle = std::atan2(delta.y(), delta.x());\n for (size_t ix = 0; ix < points.size(); ix++) {\n delta = points[ix] - pt;\n // If delta == 0, it means pt is the same as one of the vertex.\n if (IsAlmostZero(delta.squaredNorm())) return true;\n const K angle = std::atan2(delta.y(), delta.x());\n const K delta_angle = DeltaAngle(angle, last_angle);\n // If delta == +/- pi, it means pt is on one of the segment.\n if (IsAlmostEqualRelative(std::abs(delta_angle), Pi)) {\n return true;\n }\n sum_angle += delta_angle;\n last_angle = angle;\n }\n return std::abs(sum_angle) > Pi;\n }\n\n // Returns the distance of a point from the polygon edges\n K distance(const Vector_t& pt, Vector_t* grad = nullptr) const {\n K squared_dist = std::numeric_limits::max();\n for (size_t ix = 0; ix < points.size(); ix++) {\n const LineSegment edge(points[ix], points[(ix + 1) % points.size()]);\n const Vector_t closest = ClosestPointToLine(edge, pt);\n const K dist = (pt - closest).squaredNorm();\n if (dist < squared_dist) {\n squared_dist = dist;\n if (grad) *grad = pt - closest;\n }\n }\n if (grad) grad->normalize();\n return std::sqrt(squared_dist);\n }\n\n // Returns the signed distance of a point from the polygon (negative means inside the polygon)\n K signedDistance(const Vector_t& pt, Vector_t* grad = nullptr) const {\n const K dist = distance(pt, grad);\n // If the point is inside the polygon, we need to revert the direction of the gradient.\n if (isInside(pt)) {\n if (grad) *grad = -(*grad);\n return -dist;\n }\n return dist;\n }\n\n // Returns the signed area of the polygon\n // https://mathworld.wolfram.com/PolygonArea.html\n K signedArea() const {\n K area = K(0);\n for (size_t curr = 0, prev = points.size()-1; curr < points.size(); curr++) {\n area += CrossProduct(points[prev], points[curr]);\n prev = curr;\n }\n return area / K(2);\n }\n\n // Returns the centroid of the polygon\n // https://en.wikipedia.org/wiki/Centroid#Of_a_polygon\n Vector_t centroid() const {\n if (points.size() < 3) {\n if (points.empty()) return Vector_t::Zero();\n return (points.front() + points.back()) / K(2);\n }\n Vector_t centroid = Vector_t::Zero();\n for (size_t curr = 0, prev = points.size()-1; curr < points.size(); curr++) {\n const K cross_product = CrossProduct(points[prev], points[curr]);\n centroid += (points[prev] + points[curr]) * cross_product;\n prev = curr;\n }\n return centroid / (K(6) * signedArea());\n }\n\n // Returns the minimum circle that contains the polygon.\n Circle boundingCircle() const {\n std::vector indices(points.size());\n std::vector border;\n for (size_t idx = 0; idx < points.size(); idx++) {\n indices[idx] = idx;\n }\n // Random order to improve performance\n std::random_device rd;\n std::mt19937 gen(rd());\n std::shuffle(indices.begin(), indices.end(), gen);\n // Compute the center when the number of vertices is less or equal to 3\n auto trivialCenter = [&](const std::vector& indices) -> Circle {\n switch (indices.size()) {\n // Edge case for empty polygon, there is no real good answer, but any circle of radius 0\n // is technically a good answer.\n case 0: return {Vector_t::Zero(), K(0)};\n // If the polygon has a single point, then it's the center of the circle of radius 0.\n case 1: return {points[indices[0]], K(0)};\n // For two points, the center is the center of the segment, and the radius can be computed\n // using one of the extremity.\n case 2: {\n const Vector_t delta = (points[indices[1]] - points[indices[0]]) / K(2);\n return {points[indices[0]] + delta, delta.norm()};\n }\n // There is a formula for a triangle:\n // https://en.wikipedia.org/wiki/Circumscribed_circle#Cartesian_coordinates_2\n case 3: {\n const Vector_t& A = points[indices[0]];\n const Vector_t& B = points[indices[1]] - A;\n const Vector_t& C = points[indices[2]] - A;\n const K b_squared_norm = B.squaredNorm();\n const K c_squared_norm = C.squaredNorm();\n const K d = K(2) * CrossProduct(B, C);\n const Vector_t center = Vector_t(\n b_squared_norm * C.y() - c_squared_norm * B.y(),\n c_squared_norm * B.x() - b_squared_norm * C.x()) / d;\n return {A + center, center.norm()};\n }\n default:\n PANIC(\"Invalid size: %zd\", indices.size());\n }\n return {Vector_t::Zero(), K(0)};\n };\n // Implementation of the welzl algorithm:\n // https://en.wikipedia.org/wiki/Smallest-circle_problem#Welzl's_algorithm\n auto welzl = [&](auto welzl, std::vector& indices, std::vector& border) {\n if (indices.empty() || border.size() == 3) return trivialCenter(border);\n size_t p = indices.back();\n indices.pop_back();\n auto circle = welzl(welzl, indices, border);\n if (circle.isInside(points[p])) {\n indices.push_back(p);\n return circle;\n }\n border.push_back(p);\n circle = welzl(welzl, indices, border);\n border.pop_back();\n indices.push_back(p);\n return circle;\n };\n return welzl(welzl, indices, border);\n }\n\n // Returns whether both polygons intersect. If one polygon is fully inside the other, then the\n // function returns false.\n bool intersect(const Polygon2& polygon) const {\n return intersectImpl<1>(polygon.points);\n }\n\n // Returns whether this polygon intersect with the polyline.\n bool intersect(const Polyline& polyline) const {\n return intersectImpl<0>(polyline);\n }\n\n // Returns the distance between two polygons.\n // If one polygon is stricly included in the other, the distance will be negative.\n K distance(const Polygon2& polygon) const {\n const K squared_dist = squaredDistanceImpl<1>(polygon.points);\n if (squared_dist == K(0)) return K(0);\n const auto bounding_box_a = getBoundingBox();\n const auto bounding_box_b = polygon.getBoundingBox();\n // If the bounding box A encapsulates B, then B might be inside A\n if (bounding_box_a.min().x() < bounding_box_b.min().x() &&\n bounding_box_b.max().x() < bounding_box_a.max().x() &&\n bounding_box_a.min().y() < bounding_box_b.min().y() &&\n bounding_box_b.max().y() < bounding_box_a.max().y()) {\n return isInside(polygon.points.front()) ? -std::sqrt(squared_dist) : std::sqrt(squared_dist);\n }\n\n // If the bounding box B encapsulates A, then A might be inside B\n if (bounding_box_b.min().x() < bounding_box_a.min().x() &&\n bounding_box_a.max().x() < bounding_box_b.max().x() &&\n bounding_box_b.min().y() < bounding_box_a.min().y() &&\n bounding_box_a.max().y() < bounding_box_b.max().y()) {\n return polygon.isInside(points.front()) ? -std::sqrt(squared_dist) : std::sqrt(squared_dist);\n }\n\n return std::sqrt(squared_dist);\n }\n\n // Returns the distance between this polygon and a polyline.\n // If the polyline is stricly included in this polygon, the distance will be negative.\n K distance(const Polyline& polyline) const {\n const K squared_dist = squaredDistanceImpl<0>(polyline);\n if (squared_dist == K(0)) return K(0);\n return isInside(polyline.front()) ? -std::sqrt(squared_dist) : std::sqrt(squared_dist);\n }\n\n // Returns the bounding box, aligned with the axis, that contain this polygon.\n Rectangle getBoundingBox() const {\n if (points.empty()) {\n return Rectangle::FromOppositeCorners(Vector2::Zero(), Vector2::Zero());\n }\n Vector2 min = points.front();\n Vector2 max = points.front();\n for (const auto& pt : points) {\n min = min.cwiseMin(pt);\n max = max.cwiseMax(pt);\n }\n return Rectangle::FromOppositeCorners(min, max);\n }\n\n // Casts to a different type\n template ::value, int> = 0>\n Polygon2 cast() const {\n std::vector> pts;\n pts.reserve(points.size());\n for (const auto& pt : points) {\n pts.emplace_back(pt.template cast());\n }\n return Polygon2{std::move(pts)};\n }\n template::value, int> = 0>\n const Polygon2& cast() const {\n // Nothing to do as the type does not change\n return *this;\n }\n\n private:\n // Implementation of the squaredDistance using a polyline.\n // If loop is 1, then we close the polyline (making it a polygon).\n template\n K squaredDistanceImpl(const Polyline& polyline) const {\n static_assert(Loop >= 0 && Loop <= 1, \"Loop must be 0 or 1\");\n // Check for an intersection\n if (intersectImpl(polyline)) return K(0);\n // Find the closest point of either polygon to the other one.\n K squared_dist = std::numeric_limits::max();\n // For all the points of this polygon, we check the distance to all the segments of the other\n // polygon.\n for (size_t ax = 0; ax < points.size(); ax++) {\n const Vector2& a = points[ax];\n const Vector2& b = points[(ax + 1) % points.size()];\n for (size_t bx = 0; bx < polyline.size(); bx++) {\n squared_dist = std::min(squared_dist, DistanceSquaredPointToSegment(a, b, polyline[bx]));\n }\n }\n // For all the points of the other polygon, we check the distance to all the segments of this\n // polygon.\n for (size_t ax = 1; ax < polyline.size() + Loop; ax++) {\n const Vector2& a = polyline[ax - 1];\n const Vector2& b = polyline[ax % polyline.size()];\n for (size_t bx = 0; bx < points.size(); bx++) {\n squared_dist = std::min(squared_dist, DistanceSquaredPointToSegment(a, b, points[bx]));\n }\n }\n return squared_dist;\n }\n\n // Implementation of the intersect function with a polyline.\n // If loop is 1, then we close the polyline (making it a polygon).\n template\n K intersectImpl(const Polyline& polyline) const {\n static_assert(Loop >= 0 && Loop <= 1, \"Loop must be 0 or 1\");\n const auto bounding_box_a = getBoundingBox();\n const auto bounding_box_b = Polygon2{polyline}.getBoundingBox();\n if (bounding_box_a.min().x() > bounding_box_b.max().x() ||\n bounding_box_b.min().x() > bounding_box_a.max().x() ||\n bounding_box_a.min().y() > bounding_box_b.max().y() ||\n bounding_box_b.min().y() > bounding_box_a.max().y()) {\n return false;\n }\n for (size_t ax = 0; ax < points.size(); ax++) {\n const LineSegment a(points[ax], points[(ax + 1) % points.size()]);\n for (size_t bx = 1; bx < polyline.size() + Loop; bx++) {\n const LineSegment b(polyline[bx - 1], polyline[bx % polyline.size()]);\n if (AreLinesIntersecting(a, b)) return true;\n }\n }\n return false;\n }\n};\n\n// A polygon in 3D, the last point and first point are connected\ntemplate \nstruct Polygon3 {\n // Type of a point.\n using Vector_t = Vector3;\n using Scalar = K;\n\n std::vector points;\n};\n\nusing Polygon2D = Polygon2;\nusing Polygon2F = Polygon2;\nusing Polygon3D = Polygon3;\nusing Polygon3F = Polygon3;\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/polyline.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace geometry {\n\n// A polyline is currently simply a list of points\ntemplate \nusing Polyline = std::vector>;\n\nusing Polyline2d = Polyline;\nusing Polyline2f = Polyline;\nusing Polyline3d = Polyline;\nusing Polyline3f = Polyline;\n\n} // namespace geometry\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/geometry/types.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/geometry/line.hpp\"\n#include \"gems/geometry/line_segment.hpp\"\n#include \"gems/geometry/n_cuboid.hpp\"\n#include \"gems/geometry/n_sphere.hpp\"\n#include \"gems/geometry/plane.hpp\"\n#include \"gems/geometry/polygon.hpp\"\n#include \"gems/geometry/polyline.hpp\"\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/gxf_helpers/expected_macro_abstract.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/logger.hpp\"\n\n// This file defines macro helpers that can be used to check the result of an expression. Note that\n// this is an abstract implementation that has no knowledge of the result types it can be used with.\n// In order to use the macro it has to be configured first for a specific result type.\n//\n// Taxonomy:\n// - Result Type: The union of both status and unwrappable types.\n// - Status Type: A type that is used as the return type of an expression and holds the return\n// status of the expression, eg. bool, int, enum etc.\n// - Unwrappable Type: A type that is used as the return type of an expression and holds both the\n// return status and the return value of the expression, eg. std::optional,\n// nvidia::Expected etc.\n\n// Concatenates its two arguments.\n#define EXPECTED_MACRO_INTERNAL_CONCAT(a, b) EXPECTED_MACRO_INTERNAL_CONCAT_IMPL(a, b)\n#define EXPECTED_MACRO_INTERNAL_CONCAT_IMPL(a, b) a##b\n\n// Converts its argument to a string at compile time.\n#define EXPECTED_MACRO_INTERNAL_TO_STRING(x) EXPECTED_MACRO_INTERNAL_TO_STRING_IMPL(x)\n#define EXPECTED_MACRO_INTERNAL_TO_STRING_IMPL(x) #x\n\n// Gets the current location in the source code in the format \"file:line\".\n#define EXPECTED_MACRO_INTERNAL_FILE_LINE() __FILE__ \":\" EXPECTED_MACRO_INTERNAL_TO_STRING(__LINE__)\n\n// Helper to support logging a default message and an optional custom message.\n#define EXPECTED_MACRO_INTERNAL_LOG_IN_EXPECT_MACRO(expression_result, expression_string, ...) \\\n nvidia::expected_macro::LogHelper( \\\n __FILE__, __LINE__, expression_result, expression_string, ##__VA_ARGS__);\n\n// Helper to check the return type of the expression used in RETURN_IF_ERROR.\n#define EXPECTED_MACRO_INTERNAL_CHECK_EXPRESSION_IS_RESULT(expression_result) \\\n static_assert( \\\n nvidia::expected_macro::config::IsStatus::value || \\\n nvidia::expected_macro::config::IsUnwrappable::value , \\\n EXPECTED_MACRO_INTERNAL_FILE_LINE() \\\n \": RETURN_IF_ERROR can only be used with expressions that return a result type. You \" \\\n \"can register a type as a result type unwrappable with one of\" \\\n \"`template <> struct IsUnwrappable : std::true_type {};` or \" \\\n \"`template <> struct IsStatus : std::true_type {}`. \");\n\n// Helper to check the return type of the expression used in UNWRAP_OR_RETURN.\n#define EXPECTED_MACRO_INTERNAL_CHECK_EXPRESSION_IS_UNWRAPPABLE(expression_result) \\\n static_assert( \\\n nvidia::expected_macro::config::IsUnwrappable::value, \\\n EXPECTED_MACRO_INTERNAL_FILE_LINE() \\\n \": UNWRAP_OR_RETURN can only be used with expressions that return an unwrappable type. \" \\\n \"You can register a type as being unwrappable with \" \\\n \"`template <> struct IsUnwrappable : std::true_type {};`. For expressions \" \\\n \"returning a status instead of an unwrappable use `RETURN_IF_ERROR` instead.\");\n\n// Evaluates an expression that returns a result type. If the returned result contains an error it\n// returns the error. This macro can only be used in functions that also return a result type.\n//\n// Per default the macro already creates an error message that includes the evaluated expression. If\n// needed an optional string can be passed that will be appended to the default error message. It is\n// also possible to use format specifiers to customize the string.\n//\n// It is also possible to pass the Severity used for logging as an additional argument. This is\n// required if using a custom error message.\n//\n// Example:\n// Expected DoSomething();\n// Expected DoAnotherThing();\n//\n// Expected foo(){\n// RETURN_IF_ERROR(DoSomething());\n// RETURN_IF_ERROR(DoAnotherThing(), Severity::WARNING);\n// RETURN_IF_ERROR(DoAnotherThing(), Severity::WARNING, \"Custom error message.\");\n// }\n#define RETURN_IF_ERROR(expression, ...) \\\n do { \\\n auto maybe_result = (expression); \\\n EXPECTED_MACRO_INTERNAL_CHECK_EXPRESSION_IS_RESULT(maybe_result) \\\n if (!nvidia::expected_macro::config::IsValid(maybe_result)) { \\\n EXPECTED_MACRO_INTERNAL_LOG_IN_EXPECT_MACRO(maybe_result, #expression, ##__VA_ARGS__) \\\n return nvidia::expected_macro::ProxyFactory::FromStatusOrUnwrappable(maybe_result); \\\n } \\\n } while (0)\n\n// Evaluates an expression that returns a type that can be casted to a boolean. If the expression is\n// false it returns an error. This macro can only be used in functions returning a result type.\n//\n// The difference to RETURN_IF_ERROR is that this macro will always cast the expression to a\n// boolean. Thus if your expression returns a status that can be more than just true/false you will\n// loose the additional information. In those cases RETURN_IF_ERROR is preferred. Use this macro\n// only to check preconditions like a < b, or c != nullptr.\n//\n// Per default the macro already creates an error message that includes the evaluated expression. If\n// needed an optional string can be passed that will be appended to the default error message. It is\n// also possible to use format specifiers to customize the string.\n//\n// It is also possible to pass the Severity used for logging as an additional argument. This is\n// required if using a custom error message.\n//\n// Example:\n// Expected foo(){\n// RETURN_IF_FALSE(1 > 2);\n// RETURN_IF_FALSE(1 > 2, Severity::WARNING);\n// RETURN_IF_FALSE(1 > 2, Severity::WARNING, \"1 is not bigger than 2\");\n// }\n#define RETURN_IF_FALSE(expression, ...) \\\n do { \\\n const bool result = static_cast(expression); \\\n if (!result) { \\\n EXPECTED_MACRO_INTERNAL_LOG_IN_EXPECT_MACRO(result, #expression, ##__VA_ARGS__) \\\n return nvidia::expected_macro::ProxyFactory::FromStatusOrUnwrappable(result); \\\n } \\\n } while (0)\n\n// Evaluates an expression that returns an unwrappable type. If the returned type contains an error\n// it returns the error, else it unwraps the value. This macro can only be used in functions\n// returning a result type.\n//\n// Per default the macro already creates an error message that includes the evaluated expression. If\n// needed an optional string can be passed that will be appended to the default error message. It is\n// also possible to use format specifiers to customize the string.\n//\n// It is also possible to pass the Severity used for logging as an additional argument.\n//\n// Note that this macro uses expression-statements (i.e. the ({ }) surrounding the macro) which are\n// a non-standard functionality. However they are present in almost all compilers. We currently only\n// know of MSVC that does not support this.\n//\n// Example:\n// Expected GetString();\n// Expected GetAnotherString();\n//\n// Expected CountCombinedStringLength(){\n// const std::string str1 = UNWRAP_OR_RETURN(GetString());\n// std::string str2;\n// str2 = UNWRAP_OR_RETURN(GetAnotherString(), \"This should not fail. Str1 has value %s.\",\n// str1.c_str());\n// const std::string str3 = UNWRAP_OR_RETURN(GetAnotherString(), Severity::WARNING);\n// const std::string str4 = UNWRAP_OR_RETURN(GetAnotherString(), Severity::WARNING,\n// \"Custom error message\");\n// return str1.size() + str2.size() + str3.size() + str4.size();\n// }\n#define UNWRAP_OR_RETURN(expression, ...) \\\n ({ \\\n auto maybe_result = (expression); \\\n EXPECTED_MACRO_INTERNAL_CHECK_EXPRESSION_IS_UNWRAPPABLE(maybe_result) \\\n if (!nvidia::expected_macro::config::IsValid(maybe_result)) { \\\n EXPECTED_MACRO_INTERNAL_LOG_IN_EXPECT_MACRO(maybe_result, #expression, ##__VA_ARGS__) \\\n return nvidia::expected_macro::ProxyFactory::FromUnwrappable(maybe_result); \\\n } \\\n std::move(maybe_result.value()); \\\n })\n\n// All functions in the following namespace have to be specialized for a given result type in order\n// to enable the macro for the type.\nnamespace nvidia::expected_macro::config {\n\n// Type trait to check if a type can be used as a status.\ntemplate \nstruct IsStatus : std::false_type {};\n\n// Type trait to check if a type can be used as an unwrappable.\ntemplate \nstruct IsUnwrappable : std::false_type {};\n\n// The value that represents the default error for a given status type.\ntemplate \nconstexpr Status DefaultError();\n\n// Check if a result types is valid.\ntemplate \nconstexpr bool IsValid(const Result& result) {\n return static_cast(result);\n}\n\n// Helper struct to get the status type of a result. This is needed for the StatusValue helper below\n// to automatically infer the return type.\n//\n// Per default we use the same type as the\n// result, which holds for all status types. Thus this only has to be specialized for unwrappable\n// types.\ntemplate \nstruct StatusType {\n using Type = Result;\n};\n\n// Helper function to get the status of a result. We have to use a static member function instead of\n// a free function because we want the possibility for a user to only provide a partial template\n// specialization of this.\ntemplate \nstruct StatusValue {\n static constexpr typename StatusType::Type Get(const Result& result) { return result; }\n};\n\n// Get the name corresponding to a status, s.t. it can be printed.\ntemplate \nstruct StatusName {\n static std::string Get(Status status);\n};\n\n// Get the invalid unwrappable corresponding to an unwrappable. Eg. std::nullopt for std::optional.\ntemplate \nstruct InvalidUnwrappable {\n static Unwrappable Get(Status status);\n};\n\n} // namespace nvidia::expected_macro::config\n\nnamespace nvidia::expected_macro {\n\n// The default severity used for logging.\nconstexpr ::nvidia::isaac::logger::Severity kDefaultSeverity =\n ::nvidia::isaac::logger::Severity::ERROR;\n\n// Syntactic sugar to get the status of a result without having to explicitly specify all template\n// arguments.\ntemplate \nconstexpr typename config::StatusType::Type GetStatus(const Result& result) {\n return config::StatusValue::Get(result);\n}\n\n// Syntactic sugar to get the status name without having to explicitly specify all template\n// arguments.\ntemplate \nstd::string GetStatusName(Status status) {\n return config::StatusName::Get(status);\n}\n\n// Syntactic sugar to get the invalid unwrappable without having to explicitly specify all template\n// arguments.\ntemplate \nUnwrappable GetInvalidUnwrappable(Status status) {\n return config::InvalidUnwrappable::Get(status);\n}\n\ntemplate \nclass ResultProxy;\n\n// ProxyFactory to create an ResultProxy. We create a separate class for these functions\n// because ResultProxy is templated and thus could not be used without explicitly\n// specifying the template.\nclass ProxyFactory {\n public:\n // Constructs the proxy from an unwrappable type. The unwrappable has to be in an error state. We\n // do not check this because the macro should have already done this check. We use static\n // methods instead of constructors to explicitly disallow construction from certain types in\n // different situations.\n template <\n typename Unwrappable, typename = std::enable_if_t::value>>\n static ResultProxy::Type> FromUnwrappable(\n const Unwrappable& unwrappable) {\n return ResultProxy(GetStatus(unwrappable));\n }\n\n // Constructs the proxy from a status type. The status has to be in an error state. We do not\n // check this because the macro should have already done this check. We use static methods instead\n // of constructors to explicitly disallow construction from certain types in different situations.\n template \n static ResultProxy::Type> FromStatusOrUnwrappable(\n const Result& result) {\n return ResultProxy(GetStatus(result));\n }\n};\n\n// A proxy class to allow implicit casting of one result type to another result type. Thus in a\n// function that returns a result type one can simply return this proxy and then it will implicitly\n// cast to the appropriate return type.\ntemplate \nclass ResultProxy {\n public:\n // Casts the proxy to a status or unwrappable type. Note that this cast is not allowed to be\n // explicit.\n template <\n typename T,\n typename = std::enable_if_t::value || config::IsUnwrappable::value>>\n constexpr operator T() const {\n if constexpr (config::IsStatus::value) {\n return castToStatus();\n } else {\n return castToInvalidUnwrappable();\n }\n }\n\n private:\n // Constructs the proxy from a status type. The status has to be in an error state.\n // We do not check for this because we rely on the macro already having done that check.\n constexpr explicit ResultProxy(Status error) : error_(error) {}\n\n // Casts the proxy to a status type. If the error type is not equal to the proxy's error type,\n // a default error is used.\n template \n constexpr OtherStatus castToStatus() const {\n static_assert(config::IsStatus::value, \"OtherStatus has to be a status type.\");\n if constexpr (std::is_same_v) {\n return error_;\n } else {\n return config::DefaultError();\n }\n }\n\n // Casts the proxy to an invalid unwrappable type (eg. std::nullopt or nvidia::Unexpected).\n template \n constexpr Unwrappable castToInvalidUnwrappable() const {\n static_assert(\n config::IsUnwrappable::value, \"Unwrappable has to be a status type.\");\n using OtherStatus = typename config::StatusType::Type;\n return GetInvalidUnwrappable(castToStatus());\n }\n\n Status error_;\n // TODO: enable the following.\n // static_assert(config::IsStatus::value, \"Status has to be a status type.\");\n\n friend ProxyFactory;\n};\n\n// Helper function for the logging in the above macros. This version should be used when the user\n// also specifies the logging severity. The variadic arguments can be used to do string\n// interpolation in the custom_text variable.\ntemplate \nvoid LogHelper(\n const char* file, int line, const ExpressionResult& expression_result,\n const std::string& expression_string, ::nvidia::isaac::logger::Severity severity,\n const std::string& custom_txt = \"\", Args... args) {\n const auto error = GetStatus(expression_result);\n const std::string text = \"Expression '\" + expression_string + \"' failed with error '\" +\n GetStatusName(error) + \"'. \" + custom_txt;\n\n // GCC is not able to do format security validation when the string\n // is coming from a variadic template, even if the string is\n // originally a char* ignore this warning until a more recent GCC\n // version fixes this behavior\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wformat-security\"\n ::nvidia::isaac::logger::Log(file, line, severity, text.c_str(), args...);\n#pragma GCC diagnostic pop\n}\n\n// Overload of the LogHelper above. This version does not take the severity as an argument and used\n// the default severity instead.\ntemplate \nvoid LogHelper(\n const char* file, int line, const ExpressionResult& expression_result,\n const std::string& expression_string, const std::string& custom_text = \"\", Args... args) {\n LogHelper(\n file, line, expression_result, expression_string, kDefaultSeverity, custom_text, args...);\n}\n\n} // namespace nvidia::expected_macro\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/gxf_helpers/expected_macro_common.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/gxf_helpers/expected_macro_abstract.hpp\"\n#include \"magic_enum.hpp\" // NOLINT(build/include)\n\n// This file contains the configuration to use the expected macro with different return types like\n// bool, int, std::optional (and in the future std::expected).\n\n//////////////////////////////////////////\n// Configuration for using bool as status:\n//////////////////////////////////////////\nnamespace nvidia::expected_macro::config {\ntemplate <>\nstruct IsStatus : std::true_type {};\n\ntemplate <>\nconstexpr bool DefaultError() {\n return false;\n}\n\ntemplate <>\nstruct StatusName {\n static std::string Get(bool status) { return status ? \"Success\" : \"Failure\"; }\n};\n\n/////////////////////////////////////////\n// Configuration for using int as status:\n/////////////////////////////////////////\ntemplate <>\nstruct IsStatus : std::true_type {};\n\ntemplate <>\nconstexpr bool IsValid(const int& status) {\n return status == 0;\n}\n\ntemplate <>\nconstexpr int DefaultError() {\n return 1;\n}\n\ntemplate <>\nstruct StatusName {\n static std::string Get(int status) { return std::to_string(status); }\n};\n\n//////////////////////////////////////////\n// Configuration for using enum as status:\n//////////////////////////////////////////\ntemplate \nstruct StatusName>> {\n static std::string Get(EnumStatus status) { return std::string(magic_enum::enum_name(status)); }\n};\n\n////////////////////////////////////////////////////////\n// Configuration for using std::optional as unwrappable:\n////////////////////////////////////////////////////////\ntemplate \nstruct IsUnwrappable> : std::true_type {};\n\ntemplate \nstruct StatusType> {\n using Type = bool;\n};\n\ntemplate \nstruct StatusValue> {\n static constexpr bool Get(const std::optional& optional) { return optional.has_value(); }\n};\n\ntemplate \nstruct InvalidUnwrappable, bool> {\n static std::optional Get(bool status) { return std::nullopt; }\n};\n\n} // namespace nvidia::expected_macro::config\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/gxf_helpers/expected_macro_cuda.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gxf/core/expected_macro.hpp\"\n\nnamespace nvidia::expected_macro {\n\ntemplate <>\nstruct IsStatus : std::true_type {};\n\ntemplate <>\nconstexpr bool IsValid(const cudaError_t& status) {\n return status == cudaSuccess;\n}\n\ntemplate <>\nconstexpr cudaError_t DefaultError() {\n return cudaErrorUnknown;\n}\n\ntemplate <>\nstruct StatusName {\n static std::string Get(cudaError_t status) { return std::string(cudaGetErrorString(status)); }\n};\n\n} // namespace nvidia::expected_macro\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/gxf_helpers/expected_macro_gxf.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"common/expected.hpp\"\n#include \"gxf/core/expected_macro.hpp\"\n#include \"gxf/core/gxf.h\"\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/gxf_helpers/expected_macro_isaac.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/expected.hpp\"\n#include \"gxf/core/expected_macro.hpp\"\n\n// This customizes the expected macro, s.t. it can be used with ::nvidia::isaac::Expected.\nnamespace nvidia::expected_macro {\n\n//////////////////////////////////////////////////////////////////\n// Configuration for using nvidia::isaac::Expected as unwrappable:\n//////////////////////////////////////////////////////////////////\ntemplate \nstruct IsUnwrappable<::nvidia::isaac::Expected> : std::true_type {};\n\ntemplate \nstruct StatusType<::nvidia::isaac::Expected> {\n using Type = Status;\n};\n\ntemplate \nstruct StatusValue<::nvidia::isaac::Expected> {\n static constexpr Status Get(const ::nvidia::isaac::Expected& expected) {\n return expected.error();\n }\n};\n\ntemplate \nstruct InvalidUnwrappable<::nvidia::isaac::Expected, Status> {\n static ::nvidia::isaac::Expected Get(Status status) {\n return ::nvidia::isaac::Unexpected(status);\n }\n};\n\n} // namespace nvidia::expected_macro\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/gxf_helpers/image_view.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \"gems/core/image/image.hpp\"\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/tensor/tensor.hpp\"\n#include \"gxf/core/expected.hpp\"\n#include \"gxf/std/tensor.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Creates an Isaac image view of a GXF host tensor\n// Note that N here is the number of CHANNELS, not the number of dimensions.\n// N = 1: single-channel image, N = 3: 3-channel image, etc.\ntemplate \ngxf::Expected<::nvidia::isaac::ImageView> ToIsaacImageView(gxf::Tensor& tensor) {\n if (tensor.storage_type() != gxf::MemoryStorageType::kHost) {\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n\n // Check if shape is compatible\n if (N < 1) {\n GXF_LOG_ERROR(\"Channel count (%d) must be at least 1\", N);\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n } else if (N == 1) {\n if (tensor.rank() != 2 && !(tensor.rank() == 3 && tensor.shape().dimension(2) == 1)) {\n GXF_LOG_ERROR(\"Either rank is 2, or rank is 3 and the number of channels is 1. \"\n \"Channel count: %d, rank: %d\", N, tensor.rank());\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n } else { // N > 1\n if (tensor.rank() != 3) {\n GXF_LOG_ERROR(\"If channel count is greater than 1, rank must be 3.\"\n \"Channel count: %d, rank: %d\", N, tensor.rank());\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n }\n const size_t rows = tensor.shape().dimension(0);\n const size_t cols = tensor.shape().dimension(1);\n\n auto maybe_ptr = tensor.data();\n if (!maybe_ptr) {\n return gxf::ForwardError(maybe_ptr);\n }\n\n return ::nvidia::isaac::CreateImageView(maybe_ptr.value(), rows, cols);\n}\n\n// Creates an Isaac image const view of a GXF host tensor\n// Note that N here is the number of CHANNELS, not the number of dimensions.\n// N = 1: single-channel image, N = 3: 3-channel image, etc.\ntemplate \ngxf::Expected<::nvidia::isaac::ImageConstView> ToIsaacImageView(const gxf::Tensor& tensor) {\n if (tensor.storage_type() != gxf::MemoryStorageType::kHost) {\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n if ((N == 1 && tensor.rank() != 2) || (N > 1 && tensor.rank() != 3)) {\n GXF_LOG_ERROR(\"N: %d Tensor rank: %d\", N, tensor.rank());\n return gxf::Unexpected{GXF_INVALID_DATA_FORMAT};\n }\n const size_t rows = tensor.shape().dimension(0);\n const size_t cols = tensor.shape().dimension(1);\n\n auto maybe_ptr = tensor.data();\n if (!maybe_ptr) {\n return gxf::ForwardError(maybe_ptr);\n }\n\n return ::nvidia::isaac::CreateImageConstView(maybe_ptr.value(), rows, cols);\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/image/color.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"gems/core/image/image.hpp\"\n#include \"gems/core/math/utils.hpp\"\n#include \"gems/core/tensor/tensor.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Maps the unit interval [0,1[ to a 8-bit unsigned integer clamping the value if out of bounds\n// This is the inverse function of MapUint8ToUnit.\ninline unsigned char MapUnitToUint8(float x) {\n return static_cast(Clamp(static_cast(255.0f * x + 0.5f), 0, 255));\n}\n\n// Maps an 8-bit unsigned integer to the unit interval [0,1[\n// This is the inverse function of MapUnitToUint8.\ninline float MapUint8ToUnit(unsigned char c) {\n return static_cast(c) / 255.0f;\n}\n\n// Converts a 3f pixel to a 3ub pixel by mapping [0,1] to [0,255]\ninline Pixel3ub ToPixel3ub(const Pixel3f& color) {\n return Pixel3ub{MapUnitToUint8(color[0]), MapUnitToUint8(color[1]), MapUnitToUint8(color[2])};\n}\n\n// Combines a color with an alpha value.\ninline Pixel4ub WithAlpha(const Pixel3ub& color, uint8_t alpha) {\n return Pixel4ub{color[0], color[1], color[2], alpha};\n}\n\n// Converts a 3ub pixel to a 3f pixel by mapping [0,255] to [0,1]\ninline Pixel3f ToPixel3f(const Pixel3ub& color) {\n return Pixel3f{MapUint8ToUnit(color[0]), MapUint8ToUnit(color[1]), MapUint8ToUnit(color[2])};\n}\n\n// Interpolates a color\ninline Pixel3f Interpolate(const float p, const Pixel3f& a, const Pixel3f& b) {\n const float p0 = 1.0f - p;\n return Pixel3f{p0 * a[0] + p * b[0], p0 * a[1] + p * b[1], p0 * a[2] + p * b[2]};\n}\n\n// Converts a color to hex representation, e.g. (255,128,0) -> \"#ff8000\"\nstd::string ToHexString(const Pixel3ub& color);\nstd::string ToHexString(const Pixel3ub& color, unsigned char alpha);\n\n// Some special colors\nstruct Colors {\n static Pixel3ub Black() { return Pixel3ub{0, 0, 0}; }\n static Pixel3ub White() { return Pixel3ub{255, 255, 255}; }\n static Pixel3ub Pink() { return Pixel3ub{255, 20, 147}; }\n static Pixel3ub NvidiaGreen() { return Pixel3ub{118, 185, 0}; }\n static Pixel3ub NvidiaGreen2() { return Pixel3ub{0, 72, 49}; }\n static Pixel3ub NvidiaGreen3() { return Pixel3ub{0, 132, 113}; }\n static Pixel3ub Red() { return Pixel3ub{255, 0, 0}; }\n static Pixel3ub Orange() { return Pixel3ub{255, 128, 0}; }\n static Pixel3ub Yellow() { return Pixel3ub{255, 255, 0}; }\n static Pixel3ub Green() { return Pixel3ub{0, 255, 0}; }\n static Pixel3ub Cyan() { return Pixel3ub{0, 255, 255}; }\n static Pixel3ub Blue() { return Pixel3ub{0, 0, 255}; }\n static Pixel3ub Magenta() { return Pixel3ub{255, 0, 255}; }\n};\n\n// A color gradient which can be used to interpolate a color based on a floating point number.\nclass ColorGradient {\n public:\n // Creates a black -> white gradient\n ColorGradient() { setColors({Colors::Black(), Colors::White()}); }\n // Creates a gradient using the given colors\n ColorGradient(const std::vector& colors) { setColors(colors); }\n ColorGradient(const std::initializer_list& colors) { setColors(colors); }\n // Creates a gradient using the given colors\n ColorGradient(const std::vector& colors) : colors_(std::move(colors)) {}\n ColorGradient(std::initializer_list colors) : colors_(colors.begin(), colors.end()) {}\n\n // Sets the colors of the gradient\n void setColors(const std::vector& colors) { setColors(colors.begin(), colors.end()); }\n void setColors(const std::initializer_list& colors) {\n setColors(colors.begin(), colors.end());\n }\n template \n void setColors(It begin, It end);\n\n // Get a color on the gradient for a value p between 0 and 1. p will be clamped if out of bounds.\n // If the gradient is empty pink will be returned.\n Pixel3ub operator()(float p) const;\n\n private:\n std::vector colors_;\n};\n\n// Greyscale black to white color gradient\nColorGradient BlackWhiteColorGradient();\n// Color gradient inspired by \"The Starry Night\" painting\nColorGradient StarryNightColorGradient();\n// Color gradient to match the one above on positive value and extend it in the negative value\nColorGradient StarryNightExtendedColorGradient();\n// Color gradient going from black to Nvidia green\nColorGradient BlackGreenColorGradient();\n// All rainbow colors red to magenta\nColorGradient RainbowColorGradient();\n// Rainbow colors from green to magenta\nColorGradient RainbowGreenMagentaColorGradient();\n// From white to orange to black\nColorGradient ErrorColorGradient();\n// A gradient to visualize distances (from black to brown to white to light blue)\nColorGradient DistanceColorGradient();\n// A gradient going from red to blue over broken white\nColorGradient RedBlueColorGradient();\n\n// Colorizes an image of floats using a color gradient\nvoid Colorize(\n const ImageConstView1f& input, const ColorGradient& gradient, float min, float max,\n Image3ub& colored);\n// Colorizes an image of doubles using a color gradient\nvoid Colorize(\n const ImageConstView1d& input, const ColorGradient& gradient, double min, double max,\n Image3ub& colored);\n// Colorizes a tensor of floats using a color gradient\nvoid Colorize(\n const CpuTensorConstView2f& input, const ColorGradient& gradient, float min, float max,\n Image3ub& colored);\n// Colorizes a tensor of doubles using a color gradient\nvoid Colorize(\n const CpuTensorConstView2d& input, const ColorGradient& gradient, double min, double max,\n Image3ub& colored);\n// Colorizes an image of floats using a color gradient. This asserts if the input and colored image\n// dimensions (rows/columns) do not match\nvoid Colorize(\n const ImageConstView1f& input, const ColorGradient& gradient, float min, float max,\n ImageView3ub& colored);\n// Colorizes an image view of doubles using a color gradient. This asserts if the input and\n// colored image dimensions (rows/columns) do not match\nvoid Colorize(\n const ImageConstView1d& input, const ColorGradient& gradient, double min, double max,\n ImageView3ub& colored);\n// Colorizes a tensor of floats using a color gradient. This asserts if the input and colored\n// image dimensions (rows/columns) do not match\nvoid Colorize(\n const CpuTensorConstView2f& input, const ColorGradient& gradient, float min, float max,\n ImageView3ub& colored);\n// Colorizes a tensor of doubles using a color gradient. This asserts if the input and colored\n// image dimensions (rows/columns) do not match\nvoid Colorize(\n const CpuTensorConstView2d& input, const ColorGradient& gradient, double min, double max,\n ImageView3ub& colored);\n\n// A list of colors which can be used to get a color based on an integer\nclass IndexedColors {\n public:\n // Creates a list with two colors: black and white\n IndexedColors() : colors_({Pixel3ub::Zero(), Pixel3ub{255, 255, 255}}) {}\n\n // Initializes the object with the given list of colors\n IndexedColors(std::initializer_list colors) : colors_(colors) {}\n\n // Creates a list of random colors\n IndexedColors(size_t count, size_t seed) : colors_(count) {\n colors_[0] = Pixel3ub::Zero();\n std::default_random_engine rng(seed);\n std::uniform_int_distribution rnd(0, 255);\n for (size_t i = 1; i < colors_.size(); i++) {\n colors_[i] = Pixel3ub{rnd(rng), rnd(rng), rnd(rng)};\n }\n }\n\n // Retrieves the color for the given index. If there are not enough colors the index is wrapped.\n const Pixel3ub& operator()(int index) const {\n const int value = index % colors_.size();\n return colors_[value >= 0 ? value : (value + colors_.size())];\n }\n\n private:\n std::vector colors_;\n};\n\n// 256 random colors using a default seed\nIndexedColors Random256IndexedColors();\n\n// 22 distinct colors after Sasha Trubetskoy\nIndexedColors Distinct22IndexedColors();\n\n// Colorizes an image of indices using a list of colors\ntemplate \nvoid ColorizeIndices(\n const ImageConstView& indices, const IndexedColors& colors, Image3ub& result) {\n const size_t rows = indices.rows();\n const size_t cols = indices.cols();\n result.resize(indices.dimensions());\n for (size_t row = 0; row < rows; row++) {\n for (size_t col = 0; col < cols; col++) {\n result(row, col) = colors(indices(row, col));\n }\n }\n}\n\n// Colorizes an image of indices using a list of colors. This asserts if the input and colored\n// image dimensions (rows/columns) do not match\ntemplate \nvoid ColorizeIndices(\n const ImageConstView& indices, const IndexedColors& colors, ImageView3ub& result) {\n ASSERT(\n result.rows() == indices.rows() && result.cols() == indices.cols(),\n \"Output dimension (%d, %d) != Input dimension (%d, %d)\", result.rows(), result.cols(),\n indices.rows(), indices.cols());\n\n const size_t rows = indices.rows();\n const size_t cols = indices.cols();\n for (size_t row = 0; row < rows; row++) {\n for (size_t col = 0; col < cols; col++) {\n result(row, col) = colors(indices(row, col));\n }\n }\n}\n// -------------------------------------------------------------------------------------------------\n\ntemplate \nvoid ColorGradient::setColors(It begin, It end) {\n colors_.clear();\n colors_.reserve(std::distance(begin, end));\n for (; begin != end; ++begin) {\n colors_.push_back(ToPixel3f(*begin));\n }\n}\n\ninline Pixel3ub ColorGradient::operator()(float p) const {\n if (colors_.empty()) {\n return Colors::Pink();\n }\n const float pn = static_cast(colors_.size() - 1) * p;\n const int pi = std::floor(pn);\n if (pi < 0) {\n return ToPixel3ub(colors_.front());\n }\n if (static_cast(pi + 1) >= colors_.size()) {\n return ToPixel3ub(colors_.back());\n }\n const float pr = pn - static_cast(pi);\n return ToPixel3ub(Interpolate(pr, colors_[pi], colors_[pi + 1]));\n}\n\n// Converts a pixel from RGB scheme to HSV\n// Reference for conversion: https://en.wikipedia.org/wiki/HSL_and_HSV\nvoid ConvertRGBToHSV(PixelRef3ub pixel);\n\n// Converts a pixel from HSV scheme to RGB\n// Reference for conversion: https://en.wikipedia.org/wiki/HSL_and_HSV\nvoid ConvertHSVToRGB(PixelRef3ub pixel);\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/image/io.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\n#include \"gems/algorithm/string_utils.hpp\"\n#include \"gems/core/image/image.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Gets the dimensions of an image. The dimensions are written to `shape` in the order:\n// rows (0), cols (1), channels (2).\nbool LoadImageShape(const std::string& filename, Vector3i& shape);\n\n// Loads an image from a PNG file. The function will return false if the PNG could not be loaded.\n// This can for example happen if the filename is invalid or if the PNG doesn't have the requested\n// format.\nbool LoadPng(const std::string& filename, Image1ub& image);\nbool LoadPng(const std::string& filename, Image1ui16& image);\nbool LoadPng(const std::string& filename, Image3ub& image);\nbool LoadPng(const std::string& filename, Image4ub& image);\nbool LoadPng(const std::string& filename, ImageView1ub& tensor);\nbool LoadPng(const std::string& filename, ImageView3ub& tensor);\nbool LoadPng(const std::string& filename, CpuTensorView2ub& tensor);\n\n// Loads an image from a JPEG file. The function will return false if the JPEG could not be loaded.\n// This can for example happen if the filename is invalid or if the JPEG doesn't have the requested\n// format.\nbool LoadJpeg(const std::string& filename, Image1ub& image);\nbool LoadJpeg(const std::string& filename, Image3ub& image);\nbool LoadJpeg(const std::string& filename, ImageView1ub& image);\nbool LoadJpeg(const std::string& filename, ImageView3ub& image);\n\n// Loads an image from JPEG file or PNG file. The function will return false if the image could not\n// be loaded.\nbool LoadImage(const std::string& filename, Image1ub& image);\nbool LoadImage(const std::string& filename, Image3ub& image);\nbool LoadImage(const std::string& filename, ImageView1ub& image);\nbool LoadImage(const std::string& filename, ImageView3ub& image);\n\n// Saves an image to a file in the PNG format. The function will return false if the PNG could not\n// saved. This might for example happen if the file could not be opened.\nbool SavePng(const ImageConstView1ub& image, const std::string& filename);\nbool SavePng(const ImageConstView3ub& image, const std::string& filename);\nbool SavePng(const ImageConstView4ub& image, const std::string& filename);\nbool SavePng(const ImageConstView1ui16& image, const std::string& filename);\n\n// Saves an image to a file in the JPEG format. The function will return false if the JPEG could not\n// saved. This might for example happen, if the file could not be opened. Quality of 100 means\n// nearly lossless, but slow to encode and result in bigger images. While quality of 1 is fast\n// and produce very small image with a very low quality. (Note: 75 seems a good compromise)\nbool SaveJpeg(const ImageConstView1ub& image, const std::string& filename, const int quality = 75);\nbool SaveJpeg(const ImageConstView3ub& image, const std::string& filename, const int quality = 75);\n\n// Encodes an image into a buffer in the PNG format\nvoid EncodePng(const ImageConstView1ub& image, std::vector& encoded);\nvoid EncodePng(const ImageConstView3ub& image, std::vector& encoded);\nvoid EncodePng(const ImageConstView4ub& image, std::vector& encoded);\n\n// Encodes an image into a file in the JPEG format\n// Quality of 100 is nearly lossless but slow to encode and result in bigger images while 1 is fast\n// and produce very small image with a very low quality. (Note: 75 seems a good compromise)\nvoid EncodeJpeg(const ImageConstView1ub& image, int quality, std::vector& encoded);\nvoid EncodeJpeg(const ImageConstView3ub& image, int quality, std::vector& encoded);\n\n// Decodes a PNG encoded byte string. The function will return false if the PNG could not be\n// decoded, for example if the byte string is not a valid PNG.\nbool DecodePng(const std::string& bytes, Image1ub& image);\nbool DecodePng(const std::string& bytes, Image1ui16& image);\nbool DecodePng(const std::string& bytes, Image3ub& image);\nbool DecodePng(const std::string& bytes, Image4ub& image);\nbool DecodePng(const std::string& bytes, ImageView1ub& tensor);\nbool DecodePng(const std::string& bytes, ImageView3ub& tensor);\nbool DecodePng(const std::string& bytes, CpuTensorView2ub& tensor);\n\n// Gets the dimensions of an image from a PNG encoded byte string. The dimensions are written to\n// `shape` in the order: rows (0), cols (1), channels (2).\nbool DecodePngShape(const std::string& bytes, Vector3i& shape);\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/image/utils.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gems/core/assert.hpp\"\n#include \"gems/core/buffers/algorithm.hpp\"\n#include \"gems/core/image/image.hpp\"\n#include \"gems/core/math/types.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Copies an image\ntemplate \nvoid Copy(const ImageBase& source, ImageBase& target);\n\n// Sets all pixels of an image to the given value\ntemplate \nvoid FillPixels(ImageBase& image, const Pixel& value);\n\n// Sets all elements of all pixels to the given `value`\ntemplate \nvoid FillElements(ImageBase& image, K value);\n\n// Sets all elements of all pixels to 0\ntemplate \nvoid FillElementsWithZero(ImageBase& image) {\n FillElements(image, K(0));\n}\n\n// Resize down an image by a factor N.\ntemplate \nImage Reduce(const ImageBase& img);\ntemplate \nImage Reduce(const ImageBase& img, int factor);\n\n// Enlarge an image by a factor N\ntemplate \nImage Enlarge(const Image& img);\n\n// Convert an image from a format to another given a pixel conversion function\ntemplate \nOut Convert(const In& img, F convert);\ntemplate \nvoid Convert(const In& img, Out& out, F convert);\n\n// Normalizes an image\ntemplate \nvoid Normalize(const ImageBase& input, Image1ub& output);\ntemplate \nvoid Normalize(const ImageBase& input, K min, K max, Image1ub& output);\n\n// Crops the image\ntemplate \nvoid Crop(const ImageBase& img, const Vector2i& crop_start,\n const Vector2i& crop_size, Image& dest_img);\n\n// Convert disparity to depth using baseline and focal length.\n// The disparity_img is expected to be in pixels\n// The depth will have same unit as baseline. The baseline, min_depth and max_depth should all be\n// in the same units.\ntemplate ::value, int>::type = 0>\nvoid ConvertDisparityToDepth(const ImageBase& disparity_img, K baseline,\n K focal_length_px, K min_depth, K max_depth, Image& depth_img);\n\n// Stitches two images (with same number of rows) together side by side\nvoid JoinTwoImagesSideBySide(const ImageConstView3ub& left_image,\n const ImageConstView3ub& right_image, Image3ub& joint_image);\n\n// Splits an image into two halfs\nvoid SplitImages(const ImageConstView3ub& joint, Image3ub& left, Image3ub& right);\n\n// -------------------------------------------------------------------------------------------------\n\ntemplate \nvoid Copy(const ImageBase& source,\n ImageBase& target) {\n // Asserts that images have the same shape\n ASSERT(source.rows() == target.rows(), \"row count mismatch: %zu vs %zu\",\n source.rows(), target.rows());\n ASSERT(source.cols() == target.cols(), \"col count mismatch: %zu vs %zu\",\n source.cols(), target.cols());\n // Copy the bytes\n CopyMatrixRaw(reinterpret_cast(source.element_wise_begin()),\n source.getStride(),\n BufferTraits::kStorageMode,\n reinterpret_cast(target.element_wise_begin()),\n target.getStride(),\n BufferTraits::kStorageMode,\n source.rows(), source.cols() * N * sizeof(K));\n}\n\ntemplate \nvoid FillPixels(ImageBase& image, const Pixel& pixel) {\n for (int row = 0; row < image.rows(); row++) {\n for (int col = 0; col < image.cols(); col++) {\n image(row, col) = pixel;\n }\n }\n}\n\ntemplate \nvoid FillPixels(ImageBase& image, K pixel) {\n // Use the faster FillElements for 1-channel images\n FillElements(image, pixel);\n}\n\ntemplate \nvoid FillElements(ImageBase& image, K value) {\n const int elements_per_row = image.channels() * image.cols();\n for (int row = 0; row < image.rows(); row++) {\n K* row_pointer = image.row_pointer(row);\n std::fill(row_pointer, row_pointer + elements_per_row, value);\n }\n}\n\ntemplate \nImage Reduce(const ImageBase& img) {\n Image out(img.rows() / Factor, img.cols() / Factor);\n for (int row = 0; row < out.rows(); row++) {\n for (int col = 0; col < out.cols(); col++) {\n out(row, col) = img(Factor * row, Factor * col);\n }\n }\n return out;\n}\n\ntemplate \nImage Reduce(const ImageBase& img, int factor) {\n Image out(img.rows() / factor, img.cols() / factor);\n for (int row = 0; row < out.rows(); row++) {\n for (int col = 0; col < out.cols(); col++) {\n out(row, col) = img(factor * row, factor * col);\n }\n }\n return out;\n}\n\ntemplate \nImage Enlarge(const Image& img) {\n Image out(img.rows() * NRows, img.cols() * NCols);\n for (int row = 0; row < out.rows(); row++) {\n for (int col = 0; col < out.cols(); col++) {\n out(row, col) = img(row / NRows, col / NCols);\n }\n }\n return out;\n}\n\ntemplate \nOut Convert(const In& img, F convert) {\n Out out(img.rows(), img.cols());\n for (int pixel = 0; pixel < out.num_pixels(); pixel++) {\n out[pixel] = convert(img[pixel]);\n }\n return out;\n}\n\ntemplate \nvoid Convert(const In& img, Out& out, F convert) {\n ASSERT(out.dimensions() == img.dimensions(), \"dimensions mismatch\");\n for (int pixel = 0; pixel < out.num_pixels(); pixel++) {\n out[pixel] = convert(img[pixel]);\n }\n}\n\ntemplate \nvoid Normalize(const ImageBase& input, Image1ub& output) {\n K min = input[0];\n K max = input[0];\n for (int pixel = 0; pixel < input.num_pixels(); pixel++) {\n min = std::min(min, input[pixel]);\n max = std::max(max, input[pixel]);\n }\n if (min == max) {\n min -= K(1.0);\n max += K(1.0);\n }\n output = Convert(\n input, [&](K val) { return static_cast(K(255.9) * (val - min) / (max - min)); });\n}\n\ntemplate \nvoid Normalize(const ImageBase& input, K min, K max, Image1ub& output) {\n ASSERT(min < max, \"Invalid range\");\n Convert(input, output, [&](K val) {\n return static_cast(K(255.9) * Clamp01((val - min) / (max - min)));\n });\n}\n\ntemplate \nvoid Crop(const ImageBase& img, const Vector2i& crop_start,\n const Vector2i& crop_size, Image& dest_img) {\n ASSERT((crop_start.array() >= 0).all(), \"Invalid crop start location.\");\n ASSERT((crop_size.array() > 0).all(), \"Invalid crop size.\");\n Vector2i img_size{img.rows(), img.cols()};\n ASSERT(((crop_start + crop_size).array() <= img_size.array()).all(), \"Invalid crop size\");\n\n EigenImageConstMap eigen_img(img.element_wise_begin(), img.rows(), img.cols() * N);\n dest_img.resize(crop_size[0], crop_size[1]);\n EigenImageMap eigen_dest_img(dest_img.element_wise_begin(), dest_img.rows(),\n dest_img.cols() * N);\n eigen_dest_img = eigen_img.block(crop_start[0], crop_start[1] * N, crop_size[0],\n crop_size[1] * N);\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/pose_tree/pose_tree.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include // NOLINT(build/include_order)\n#include \n#include \n#include \n\n#include \"common/unique_index_map.hpp\"\n#include \"gems/core/math/pose2.hpp\"\n#include \"gems/core/math/pose3.hpp\"\n#include \"gems/gxf_helpers/expected_macro_gxf.hpp\"\n#include \"gems/pose_tree/pose_tree_edge_history.hpp\"\n#include \"gxf/core/component.hpp\"\n#include \"gxf/std/gems/suballocators/first_fit_allocator.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// A temporal pose tree to store relative coordinate system transformations over time.\n// This implementation does not support multiple paths between the same coordinate systems at a\n// given time. It does however allow to disconnect edge and create new connection using a different\n// path. It also allows for multiple \"roots\". In fact the transformation relationships form an\n// acylic, bi-directional, not necessarily fully-connected graph.\n// This PoseTree assigned a different version id to each operation that affects it, and this version\n// can be used to make a query ignore later changes made to the tree.\nclass PoseTree : public gxf::Component {\n public:\n // Error codes used by this class.\n enum class Error {\n // kInvalidArgument is returned when a function is called with argument that does not make sense\n // such as negative number of frames.\n kInvalidArgument = 0,\n // kOutOfMemory is returned if `initialize` failed to allocate the requested memory, or if an\n // edge/frame can't be added because we run out of the pre-allocated memory.\n kOutOfMemory = 1,\n // kFrameNotFound is returned if a query is made with a frame uid that does not match any\n // existing frame.\n kFrameNotFound = 2,\n // kAlreadyExists is returned if a frame or an edge that already exist is added.\n kAlreadyExists = 3,\n // kCyclingDependency is returned if a pose is added that would create a cycle in the PoseTree\n // structure.\n kCyclingDependency = 4,\n // kFramesNotLinked is returned if a query is made between two not connected frame or if we\n // attempt to disconnect/delete an edge that does not exist.\n kFramesNotLinked = 5,\n // kPoseOutOfOrder is returned if a query is made to update the three in the past. For example\n // if we try to disconnect or update a pose at a time older than the latest update on this edge.\n kPoseOutOfOrder = 6,\n // kLogicError is used whenever an error that should not have happened happened. This should\n // never happen and are here only to prevent crashes/assert,\n kLogicError = 7,\n };\n\n // The maximum size for the name of a frame. An additional '\\0' is added at the end to make it\n // 64 characters long.\n static constexpr int32_t kFrameNameMaximumLength = 63;\n\n // Auto generated frame names will start with this prefix, followed by the uid of the frame.\n static constexpr char const* kAutoGeneratedFrameNamePrefix = \"_frame_\";\n\n // Expected type used by this class.\n template \n using Expected = nvidia::Expected;\n // Unexpected type used by this class.\n using Unexpected = nvidia::Unexpected;\n\n // Type used to uniquely identify a frame.\n using frame_t = uint64_t;\n // Type used for versioning the PoseTree.\n using version_t = uint64_t;\n // Type used as a key for the PoseTreeEdgeHistory map.\n using history_t = uint64_t;\n\n // Type for callback functions that are called every time a frame is created.\n using CreateFrameCallback = std::function;\n // Type for callback functions that are called every time an edge is set.\n using SetEdgeCallback = std::function;\n\n // Allocates space for a given number of total frames and total number of edges.\n // Total amount of memory required is approximately:\n // number_frames * 128 + number_edges * 64 + history_length * 72.\n Expected init(int32_t number_frames, int32_t number_edges, int32_t history_length,\n int32_t default_number_edges, int32_t default_history_length,\n int32_t edges_chunk_size, int32_t history_chunk_size);\n void deinit();\n\n // Returns the current PoseTree version.\n version_t getPoseTreeVersion() const;\n\n // Creates a new frame in the PoseTree. An optional name may be given to give a human-readable\n // name to the frame. The name is a null-terminated string with at most 63 characters. User\n // defined name cannot start with \"_\", which is reserved for auto generated names such as\n // \"_frame_i\", where i is the uid of the frame. hint on the maximum number of edges this frame\n // will be connected to can be provided. Returns the frame id.\n Expected createFrame(const char* name, int32_t number_edges);\n Expected createFrame(const char* name);\n Expected createFrame(int32_t number_edges);\n Expected createFrame();\n\n // Finds a frame with the given name, and returns the frame id. If no such frame exist, it returns\n // Error::kFrameNotFound\n Expected findFrame(const char* name) const;\n // Finds a frame with the given name, and returns the frame id. If no such frame exist, it creates\n // a new frame by calling the equivalent createFrame function.\n Expected findOrCreateFrame(const char* name);\n Expected findOrCreateFrame(const char* name, int32_t number_edges);\n\n // Creates an edge between the left hand side (lhs) frame and the right hand side (rhs) frame.\n // A hint on the maximum length needed can be provided.\n // Upon success, it returns the version id of the change.\n Expected createEdges(frame_t lhs, frame_t rhs);\n Expected createEdges(frame_t lhs, frame_t rhs, int32_t maximum_length);\n Expected createEdges(frame_t lhs, frame_t rhs,\n PoseTreeEdgeHistory::AccessMethod method);\n Expected createEdges(frame_t lhs, frame_t rhs, int32_t maximum_length,\n PoseTreeEdgeHistory::AccessMethod method);\n\n // Deletes a frame in the PoseTree and all its relations to other frames and frees its memory.\n // This action is permantly erasing the history information.\n // Upon success, it returns the version id of the change (however query made with a previous\n // version will also consider the frame as deleted).\n Expected deleteFrame(frame_t uid);\n // Deletes an edge and frees the memory.\n // This action is permantly erasing the history.\n // Upon success, it returns the version id of the change (however query made with a previous\n // version will also consider the edge as deleted).\n Expected deleteEdge(frame_t lhs, frame_t rhs);\n\n // Disconnects a frame from all the others starting at a given time.\n // Upon success, it returns the version id of the change.\n Expected disconnectFrame(frame_t uid, double time);\n // Disconnects an edge starting at a given time.\n // Upon success, it returns the version id of the change.\n Expected disconnectEdge(frame_t lhs, frame_t rhs, double time);\n\n // Disable all the implicit cast (to make sure to catch a call with the wrong type for the time)\n template Expected<::nvidia::isaac::Pose3d>\n disconnectFrame(Args&&... args) = delete;\n template Expected<::nvidia::isaac::Pose3d>\n disconnectEdge(Args&&... args) = delete;\n\n // Gets the name of a frame.\n Expected getFrameName(frame_t uid) const;\n\n // Gets the latest pose between two frames as well as the time of that pose.\n // The two poses needs to be directly linked\n Expected> getLatest(frame_t lhs, frame_t rhs) const;\n Expected>\n getLatest(const char* lhs, const char* rhs) const;\n\n // Gets the pose lhs_T_rhs between two frames in the PoseTree at the given time. If the poses are\n // not connected exactly at the given time, the indicated method is used to interpolate the data.\n Expected<::nvidia::isaac::Pose3d> get(frame_t lhs, frame_t rhs, double time,\n PoseTreeEdgeHistory::AccessMethod method,\n version_t version) const;\n Expected<::nvidia::isaac::Pose3d> get(frame_t lhs,\n frame_t rhs,\n double time,\n version_t version) const;\n Expected<::nvidia::isaac::Pose3d> get(frame_t lhs, frame_t rhs, double time,\n PoseTreeEdgeHistory::AccessMethod method) const;\n Expected<::nvidia::isaac::Pose3d> get(frame_t lhs, frame_t rhs, double time) const;\n\n // Same as above, but using the name as interface.\n Expected<::nvidia::isaac::Pose3d> get(const char* lhs, const char* rhs, double time,\n PoseTreeEdgeHistory::AccessMethod method,\n version_t version) const;\n Expected<::nvidia::isaac::Pose3d> get(const char* lhs, const char* rhs, double time,\n version_t version) const;\n Expected<::nvidia::isaac::Pose3d> get(const char* lhs, const char* rhs, double time,\n PoseTreeEdgeHistory::AccessMethod method) const;\n Expected<::nvidia::isaac::Pose3d> get(const char* lhs, const char* rhs, double time) const;\n\n // Disable all the implicit cast (to make sure to catch a call with the wrong type for the time)\n template Expected<::nvidia::isaac::Pose3d> get(Args&&... args) const = delete;\n\n // Helper function to get a Pose2d instead of Pose3d\n template \n Expected<::nvidia::isaac::Pose2d> getPose2XY(Args&&... args) const {\n return get(std::forward(args)...).map([](const ::nvidia::isaac::Pose3d& pose_3d) {\n return pose_3d.toPose2XY();\n });\n }\n\n // The last time at which the pose between two frames is specified.\n // TODO(bbutin): Implement the following methods.\n // Expected latest(frame_t lhs, frame_t rhs, version_t version) const;\n // Expected latest(frame_t lhs, frame_t rhs) const;\n\n // Sets the pose between two frames in the PoseTree. Note that poses can not be changed\n // retrospectively. Thus for example once the pose at time t=2.0 is set it is no longer allowed\n // to set the pose for time t <= 2.0. It is not allowed to form cycles. Frames are implicitly\n // linked. If more than the maximum number of allowed poses are set the oldest pose is deleted.\n // Upon success, it returns the version id of the change.\n Expected set(frame_t lhs, frame_t rhs, double time,\n const ::nvidia::isaac::Pose3d& lhs_T_rhs);\n // Same as above, but using the name as interface.\n Expected set(const char* lhs, const char* rhs, double time,\n const ::nvidia::isaac::Pose3d& lhs_T_rhs);\n\n // Helper function to set a Pose2d instead of Pose3d\n Expected set(frame_t lhs, frame_t rhs, double time,\n const ::nvidia::isaac::Pose2d& lhs_T_rhs) {\n return set(lhs, rhs, time, ::nvidia::isaac::Pose3d::FromPose2XY(lhs_T_rhs));\n }\n // Same as above, but using the name as interface.\n Expected set(const char* lhs, const char* rhs, double time,\n const ::nvidia::isaac::Pose2d& lhs_T_rhs) {\n return set(lhs, rhs, time, ::nvidia::isaac::Pose3d::FromPose2XY(lhs_T_rhs));\n }\n\n // Disable all the implicit cast (to make sure to catch a call with the wrong type for the time)\n // First we define a function that will match all the call with double and forward it to the\n // appropirate function. This is needed in case the Pose is provided by value.\n template \n Expected set(Frame lhs, Frame rhs, double time, const Pose lhs_T_rhs) {\n return set(lhs, rhs, time, lhs_T_rhs);\n }\n // Then we disable all the calls not made with double.\n template \n Expected set(Frame lhs, Frame rhs, T time, const Pose& lhs_T_rhs) = delete;\n\n // Get list of edges\n std::vector> edges() const;\n\n // Registers a callback function for every time a frame is created. If a callback function\n // does not already exist for the provided commponent id cid.\n Expected addCreateFrameCallback(gxf_uid_t cid, CreateFrameCallback callback);\n\n // Deregisters a callback function for time an edge is set. If there is no callback function for\n // the component id cid, this function returns an error.\n Expected removeCreateFrameCallback(gxf_uid_t cid);\n\n // Registers a callback function for every time an edge is set. If a callback function\n // does not already exist for the provided commponent id cid.\n Expected addSetEdgeCallback(gxf_uid_t cid, SetEdgeCallback callback);\n\n // Deregisters a callback function for time an edge is set. If there is no callback function for\n // the component id cid, this function returns an error.\n Expected removeSetEdgeCallback(gxf_uid_t cid);\n\n // Helper function to transform an error code into an human readable error.\n static const char* ErrorToStr(Error error);\n\n private:\n // Helper structure that stores the information about a frame.\n struct FrameInfo {\n // Array containg the list of edges.\n history_t* history;\n // Current number of edges\n int32_t number_edges;\n // Maximum number of edges allowed\n int32_t maximum_number_edges;\n // Name of the frame. It has to be null terminated, so it can hold at most 63 characters.\n char name[kFrameNameMaximumLength + 1];\n // Hint to quickly find a path:\n // Store the distance from the node to the root (== 0 if this frame is the root)\n int32_t distance_to_root;\n // Frame to follow to reach the root\n frame_t node_to_root;\n // Name of the root\n frame_t root;\n // Some helper id to computer the path between two nodes\n mutable version_t hint_version;\n // Some helper to memorize the path we took during the dfs\n mutable frame_t dfs_link;\n // Name of the frame.\n frame_t uid;\n };\n // Helper class to compare to const char*\n // TODO(ben): Remove once we get rid of map\n struct CharMapCompare {\n bool operator()(const char* lhs, const char* rhs) const {\n return std::strcmp(lhs, rhs) < 0;\n }\n };\n\n // Implementation of findOrCreateFrame\n Expected findOrCreateFrameImpl(const char* name, int32_t number_edges);\n // Implementation of findFrame\n Expected findFrameImpl(const char* name) const;\n // Implementation of createFrame\n Expected createFrameImpl(const char* name, int32_t number_edges);\n // Implementation of createEdges\n Expected createEdgesImpl(frame_t lhs, frame_t rhs, int32_t maximum_length,\n PoseTreeEdgeHistory::AccessMethod method);\n // Implementation of deleteEdge\n Expected deleteEdgeImpl(frame_t lhs, frame_t rhs, version_t version);\n // Update the path to the root for a given connected component starting from the given node.\n Expected updateRoot(frame_t root);\n // Implementation of get using the pre-computed path to the root as a hint. If it fails, it falls\n // back to getDfsImpl.\n Expected<::nvidia::isaac::Pose3d> getImpl(frame_t lhs, frame_t rhs, double time,\n PoseTreeEdgeHistory::AccessMethod method,\n version_t version) const;\n // Implementation of get that do a dfs to see if a path exists at a given time.\n Expected<::nvidia::isaac::Pose3d> getDfsImpl(frame_t lhs, frame_t rhs, double time,\n PoseTreeEdgeHistory::AccessMethod method,\n version_t version) const;\n\n // Lock to protect access to the parameter below.\n mutable std::shared_timed_mutex mutex_;\n // Lock to protect access to getDfsImpl. This function is rarely called, but can be called while\n // mutex_ is lock in read access, and getDfsImpl is modifying the dfs_link of some frames as well\n // as using the frames_stack_. We need a special protection for this function while not blocking\n // all the concurrent read which most likely won't call it.\n mutable std::mutex dfs_mutex_;\n\n // Lock to protect create_frame_callbacks_\n mutable std::shared_timed_mutex create_frame_callbacks_mutex_;\n // Callback functions for the create frame operation.\n // TODO(dbhaskara): Replace with UniqueIndexMap once it supports iteration through all elements\n std::unordered_map create_frame_callbacks_;\n\n // Lock to protect set_edge_callbacks_\n mutable std::shared_timed_mutex set_edge_callbacks_mutex_;\n // Callback functions for the set edge operation.\n // TODO(dbhaskara): Replace with UniqueIndexMap once it supports iteration through all elements\n std::unordered_map set_edge_callbacks_;\n\n // Mapping from a frame to it's index.\n // TODO(ben): We need to get rid of std::map\n std::map, history_t> edges_map_;\n\n // TODO(ben): We need to get rid of std::map, but for now UniqueIndexMap does not support\n // iterating through all the elements.\n std::map name_to_uid_map_;\n\n // Store the list of the current frame of the PoseTree.\n UniqueIndexMap frame_map_;\n\n // Used to implement a dfs.\n std::unique_ptr frames_stack_;\n\n // Store the list of PoseTreeEdgeHistory used by the frames. Each PoseTreeEdgeHistory correspond\n // to a bi-directional edge.\n UniqueIndexMap histories_map_;\n\n // Helper to `allocate` an array of PoseTreeEdgeHistory (storing only the uid).\n gxf::FirstFitAllocator histories_management_;\n\n // Helper to `allocate` an array of TimedPose.\n gxf::FirstFitAllocator poses_management_;\n\n // Current version of the PoseTree.\n frame_t version_;\n // Version of the hint. Mostly used to know if a node in the stack has been processed already.\n mutable frame_t hint_version_;\n\n // Default maximum number of edges a given frame can have\n int32_t default_number_edges_;\n // Default length of the history used by an edge.\n int32_t default_history_length_;\n};\n\n} // namespace isaac\n} // namespace nvidia\n\n// We configure the expected macro to work with PoseTree::Error. The configuration has to happen in\n// exactly this namespace.\nnamespace nvidia::expected_macro {\ntemplate <>\nstruct IsStatus<::nvidia::isaac::PoseTree::Error> : std::true_type {};\n} // namespace nvidia::expected_macro\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/pose_tree/pose_tree_edge_history.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/math/pose3.hpp\"\n#include \"gxf/core/expected.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// Class that stores an history of Poses (using pre-allocated memory and a cyclic buffer) and\n// provides helper function to add a new pose or query the pose at a given time.\nclass PoseTreeEdgeHistory {\n public:\n // Interpolation method for accessing poses in the pose tree\n enum class AccessMethod {\n // Gets the value of the closest sample\n kNearest,\n // Interpolates linearly between adjacent samples. If the query is outside the validity range,\n // the closest pose will be returned.\n kInterpolateLinearly,\n // Inter- or extrapolates linearly based on neighbouring samples. This require at least two\n // valid poses or Error::kOutOfRange will be returned.\n kExtrapolateLinearly,\n // Interpolates with slerp between adjacent samples. If the query is outside the validity range,\n // the closest pose will be returned.\n kInterpolateSlerp,\n // Inter- or extrapolates with slerp based on neighbouring samples. This require at least two\n // valid poses or Error::kOutOfRange will be returned.\n kExtrapolateSlerp,\n // Use the latest Pose before a given time.\n kPrevious,\n // Fallback to the default interpolation\n kDefault,\n };\n\n // Error codes used by this class.\n enum class Error {\n // kInvalidArgument is returned when a function is called with argument that does not make sense\n // such as querying a pose outside the valid range or provide a wrong interpolation method.\n kInvalidArgument,\n // kOutOfOrder is returned when a set/disconnected called is made with a version or time\n // lower than the latest TimedPose. Both time and version must be stricly increasing.\n kOutOfOrder,\n // kFramesNotLinked is returns if a get query is made and the tree is not connected at the given\n // time and version of the edge.\n kFramesNotLinked,\n // kOutOfRange is returned if not enough poses are available to do extrapolation or if the\n // available buffer is too small to store a new pose.\n kOutOfRange,\n };\n\n // Expected type used by this class.\n template \n using Expected = nvidia::Expected;\n // Unexpected type used by this class.\n using Unexpected = nvidia::Unexpected;\n\n // Type used to uniquely identify a frame.\n using frame_t = uint64_t;\n // Type used for versioning the edge.\n using version_t = uint64_t;\n\n // Helper structure to store the pose at a given time on the edge.\n struct TimedPose {\n // 3D pose that transforms the lhs frame into the rhs frame.\n ::nvidia::isaac::Pose3d pose;\n // Time of the pose. Needs to be strictly increasing.\n double time;\n // Version ID of the pose. Needs to be strictly increasing.\n version_t version;\n // If false, then it marks the edge as being disconnected from this current time. The pose does\n // not matter.\n bool valid;\n };\n\n // Default constructor used to be able to pre-allocate memory.\n PoseTreeEdgeHistory() = default;\n\n // Constructor to actually uses the object:\n // `buffer` is a pre allocated buffer that can old `maximum_size` elements.\n PoseTreeEdgeHistory(frame_t lhs, frame_t rhs, int32_t maximum_size, TimedPose* buffer);\n PoseTreeEdgeHistory(frame_t lhs, frame_t rhs, int32_t maximum_size, AccessMethod access_method,\n TimedPose* buffer);\n\n // Sets the pose at a given amount of time. If the array is empty Error::kOutOfMemory will be\n // returned, otherwise if a pose already exist and `time` or `version` <= pose.time/version then\n // Error::kOutOfOrder is returned. Otherwise it will succeed, and if the history already\n // contained maximum_size_ element, then the oldest pose will be forgotten.\n Expected set(double time, const ::nvidia::isaac::Pose3d& pose, version_t version);\n\n // Returns the TimedPose at a given position. If index is negative Error::kInvalidArgument will be\n // returned, and if index >= size, then Error::kOutOfRange will be returned.\n Expected at(int32_t index) const;\n\n // Returns the Pose3d at a given time using the given version of the PoseTree.\n // If no pose existed at the given time, Error::kFramesNotLinked will be returned.\n // The desired method can be provided, for kExtrapolateLinearly, at least two poses are required.\n Expected<::nvidia::isaac::Pose3d> get(double time, AccessMethod method, version_t version) const;\n\n // Disconnects a frame at a given time.\n Expected disconnect(double time, version_t version);\n\n // Returns whether or not the frame are current connected\n bool connected() const;\n\n // Resets the history, all the poses will be erased.\n void reset();\n\n // Returns the information about the latest pose\n Expected latest() const;\n\n // Returns a pointer to the buffer.\n const TimedPose* data() const {\n return edges_info_;\n }\n\n // Returns the current size.\n int32_t size() const {\n return size_;\n }\n\n // Returns the maximum number of poses this edge can contain.\n int32_t maximum_size() const {\n return maximum_size_;\n }\n\n // This edge reprensent the transformation from the rhs frame to the lhs frame. This function\n // returns the uid of the lhs frame.\n frame_t lhs() const {\n return lhs_;\n }\n\n // This edge reprensent the transformation from the rhs frame to the lhs frame. This function\n // returns the uid of the rhs frame.\n frame_t rhs() const {\n return rhs_;\n }\n\n private:\n // Reserves a new pose for a given time/version and returns it's index.\n // If there exists another pose with a later time/version, it returns kOutOfOrder.\n Expected reserveNewPose(double time, version_t version);\n\n // Mutex to protect changes to this object.\n mutable std::shared_timed_mutex mutex_;\n // Pointers to the buffer that contains the list of TimedPose (we use a circulat buffer to access\n // it).\n TimedPose* edges_info_ = nullptr;\n // Name of the frame this edge connects to.\n frame_t lhs_, rhs_;\n // Size of the buffer, aka maximum number of elements this edge can store in the same time.\n int32_t maximum_size_ = 0;\n // Current number of poses on this edge.\n int32_t size_ = 0;\n // Position of the first pose in the circular buffer,\n int32_t pos_ = 0;\n // Default access method.\n AccessMethod default_access_method_;\n};\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/serialization/base64.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/image/image.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace serialization {\n\n// Encodes an Image3ub image into a Bitmap image base 64 encoded ready to be used in HTML code.\n// WARNING: The image is converted to BMP format which requires the memory to be 4-alligned at the\n// beginning of each row. In order to avoid memory copy and keep the code efficient, the encoded\n// image might contain more additional columns filled with random data, it will be the\n// responsability of the consumer to ignore these columns.\nstd::string Base64Encode(const Image1ub& image);\nstd::string Base64Encode(const Image3ub& image);\n// Encodes some data in base 64.\nstd::string Base64Encode(const uint8_t* bytes_to_encode, size_t in_len);\n// Decode a base 64 encoded string into its original format.\nstd::string Base64Decode(const std::string& encoded_string);\n\n} // namespace serialization\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/serialization/json.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \"gems/core/optional.hpp\"\n#include \"third_party/nlohmann/json.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\n// We are using nlohmann::json as JSON\nusing Json = nlohmann::json;\n\nnamespace serialization {\n\n// Loads and parses a JSON object from a file\nJson LoadJsonFromFile(const std::string& filename);\n// Parses a JSON object from a text string\n// @deprecated\nJson LoadJsonFromText(const std::string& text);\n// Checks if the given file does not exist or is empty\nbool IsFileEmpty(const std::string& filename);\n// Appends two json objects into one: if the duplicate keys are found in the input objects,\n// values are appended as array in the output object, second value is appended at back of array\n// only works for the top level json. Combines the unqiue keys found in the input objects.\nJson AppendJson(const Json& a, const Json& b);\n\n// Loads and parses a JSON object from a file without ASSERT\n// Returns nullopt in case of failure\nstd::optional TryLoadJsonFromFile(const std::string& filename);\n\n// Writes JSON to a file\nbool WriteJsonToFile(const std::string& filename, const Json& json);\n\n// Merges two JSON objects into one: if duplicate keys are found in the input objects,\n// the value of the second object is written to the merged object.\n// Combines the unqiue keys found in the input objects.\nJson MergeJson(const Json& a, const Json& b);\n\n// Replace keys in the top level of json. In the key_map, the first value is the existing key to\n// replace and second value is the new key with which to replace it.\n// Returns the number of keys that were replaced (renaming a key to same name counts as a\n// replacement).\nint ReplaceJsonKeys(const std::map& key_map, Json& json);\n\n// Parses a JSON object from a text string\nstd::optional ParseJson(const std::string& text);\n// Parses a JSON object from a string coming from an object such as a JSON or YAML.\n// The string should be enclosed inside \"\" or '' and the internal strings have their delimiter\n// escaped. For example: \"{\\\"age\\\": 42}\".\nstd::optional ParseJsonFromString(const std::string& str);\n\n// Helper class for combining values in multiple JSON files and/or objects into one JSON object\nclass JsonOperator {\n public:\n using OperationFunction = std::function;\n\n JsonOperator(OperationFunction operation_func) : operation_function_(operation_func) {}\n\n // Add JSON file to be combined\n JsonOperator& withFile(const std::string& json_filename) & {\n json_ = operation_function_(json_, LoadJsonFromFile(json_filename));\n return *this;\n }\n\n // Add JSON file to be combined\n JsonOperator&& withFile(const std::string& json_filename) && {\n json_ = operation_function_(json_, LoadJsonFromFile(json_filename));\n return std::move(*this);\n }\n\n // Add JSON object to be combined\n JsonOperator& withJson(const Json& json) & {\n json_ = operation_function_(json_, json);\n return *this;\n }\n\n // Add JSON object to be combined\n JsonOperator&& withJson(const Json& json) && {\n json_ = operation_function_(json_, json);\n return std::move(*this);\n }\n\n // Convert to JSON using a copy\n operator Json() const& { return json_; }\n\n // Convert to JSON using a move\n operator Json() && { return std::move(json_); }\n\n private:\n // Operation function to combine JSON\n OperationFunction operation_function_;\n // JSON being combined\n Json json_;\n};\n\n} // namespace serialization\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/serialization/json_formatter.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gems/core/image/image.hpp\"\n#include \"gems/core/math/pose2.hpp\"\n#include \"gems/core/math/pose3.hpp\"\n#include \"gems/core/math/so2.hpp\"\n#include \"gems/core/math/so3.hpp\"\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/optional.hpp\"\n#include \"gems/geometry/line_segment.hpp\"\n#include \"gems/geometry/n_cuboid.hpp\"\n#include \"gems/geometry/n_sphere.hpp\"\n#include \"gems/serialization/json.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nusing Json = nlohmann::json;\n\nnamespace serialization {\n\n// Gets the value from the json for the given key.\ntemplate \nstd::optional TryGet(const Json& json);\n\n// Sets a value in the json under the given key.\ntemplate \nvoid Set(Json& json, T value);\n\n// Extracts the value for the given key from a JSON object. If the key does not exist in the JSON\n// object, or if the type does not match the desired type nullopt will be returned.\ntemplate \nstd::optional TryGetFromMap(const Json& json, const std::string& key) {\n try {\n const auto it = json.find(key);\n if (it == json.end()) {\n return std::nullopt;\n } else {\n return TryGet(*it);\n }\n } catch (...) {\n return std::nullopt;\n }\n}\n\n// Similar to `TryGetFromMap`, but will use the given default if the value could not be read\ntemplate \nT GetFromMapOrDefault(const Json& json, const std::string& key, T backup) {\n if (auto maybe = TryGetFromMap(json, key)) {\n return *maybe;\n } else {\n return std::move(backup);\n }\n}\n\n// Given key_prefix, tries to get the angle both in radians and degrees, e.g.,\n// if the key_prefix is \"yaw\", checks both \"yaw_radians\" and \"yaw_degrees\" values.\n// If only one of these keys exist, returns the angle in radians.\ntemplate ::value>>\nstd::optional TryGetAngleInRadiansFromMap(const Json& json, const std::string& key_prefix) {\n const std::string key_radians = key_prefix + \"_radians\";\n const std::string key_degrees = key_prefix + \"_degrees\";\n auto maybe_radians = TryGetFromMap(json, key_radians);\n auto maybe_degrees = TryGetFromMap(json, key_degrees);\n if (maybe_radians && maybe_degrees) {\n LOG_ERROR(\"Please set \\\"%s\\\" or \\\"%s\\\" only.\", key_radians.c_str(), key_degrees.c_str());\n return std::nullopt;\n } else if (maybe_radians) {\n return *maybe_radians;\n } else if (maybe_degrees) {\n return DegToRad(*maybe_degrees);\n }\n // Angle is not set\n return std::nullopt;\n}\n\n//--------------------------------------------------------------------------------------------------\n\nnamespace json_formatter_details {\n\n// A helper class used to format data for json.\n// Synposis:\n// static std::optional TryGet(const Json::json& json);\n// static void Set(const Json::json& json, T value);\ntemplate \nstruct JsonSerializer {\n static std::optional TryGet(const Json& json) {\n try {\n T x;\n from_json(json, x);\n return std::move(x);\n } catch (...) {\n return std::nullopt;\n }\n }\n static void Set(Json& json, T value) { to_json(json, value); }\n};\n\n// Support for getting JSON from JSON\ntemplate <>\nstruct JsonSerializer {\n static const Json& TryGet(const Json& json) { return json; }\n static void Set(Json& json, Json value) { json = std::move(value); }\n};\n\n// Parameter support for basic types: string, int, float, double, bool\n#define ISAAC_JSON_FORMATTER_FLOAT_PRIMITIVE(TYPE) \\\n template <> \\\n struct JsonSerializer { \\\n static std::optional TryGet(const Json& json) { \\\n const double* double_ptr = json.get_ptr(); \\\n if (double_ptr != nullptr) { \\\n return static_cast(*double_ptr); \\\n } \\\n const int64_t* int_ptr = json.get_ptr(); \\\n if (int_ptr == nullptr) { \\\n return std::nullopt; \\\n } else { \\\n return static_cast(*int_ptr); \\\n } \\\n } \\\n static void Set(Json& json, TYPE value) { \\\n json = static_cast(value); \\\n } \\\n };\nISAAC_JSON_FORMATTER_FLOAT_PRIMITIVE(float);\nISAAC_JSON_FORMATTER_FLOAT_PRIMITIVE(double);\n// Parameter support for basic types: string, int, float, double, bool\n#define ISAAC_JSON_FORMATTER_PRIMITIVE(TYPE, JTYPE) \\\n template <> \\\n struct JsonSerializer { \\\n static std::optional TryGet(const Json& json) { \\\n const JTYPE* ptr = json.get_ptr(); \\\n if (ptr == nullptr) { \\\n return std::nullopt; \\\n } else { \\\n return static_cast(*ptr); \\\n } \\\n } \\\n static void Set(Json& json, TYPE value) { \\\n json = static_cast(value); \\\n } \\\n };\nISAAC_JSON_FORMATTER_PRIMITIVE(uint64_t, uint64_t);\nISAAC_JSON_FORMATTER_PRIMITIVE(int64_t, int64_t);\nISAAC_JSON_FORMATTER_PRIMITIVE(int, int64_t);\nISAAC_JSON_FORMATTER_PRIMITIVE(bool, bool);\nISAAC_JSON_FORMATTER_PRIMITIVE(std::string, std::string);\n\n// Parameter support for compile-sized Vectors. It uses doubles to store elements in the json.\ntemplate \nstruct JsonSerializer> {\n static std::optional> TryGet(const Json& json) {\n if (!json.is_array()) {\n return std::nullopt;\n }\n const int json_size = static_cast(json.size());\n if (N != Eigen::Dynamic && json_size != N) {\n return std::nullopt;\n }\n Vector result(json_size);\n for (int i = 0; i < json_size; i++) {\n auto maybe = ::nvidia::isaac::serialization::TryGet(json[i]);\n if (!maybe) {\n return std::nullopt;\n }\n result[i] = *maybe;\n }\n return result;\n }\n static void Set(Json& json, const Vector& value) {\n json = Json(std::vector(value.data(), value.data() + value.size()));\n }\n template \n static void Set(Json& json, const Vector& value) {\n std::array data;\n for (int i = 0; i < M; i++) {\n data[i] = value[i];\n }\n json = Json(data);\n }\n};\n\n// For std::vector\ntemplate \nstruct JsonSerializer> {\n static std::optional> TryGet(const Json& json) {\n if (!json.is_array()) {\n return std::nullopt;\n }\n const size_t size = json.size();\n std::vector result;\n result.reserve(size);\n for (size_t i = 0; i < size; i++) {\n auto maybe = ::nvidia::isaac::serialization::TryGet(json[i]);\n if (!maybe) {\n return std::nullopt;\n }\n result.push_back(*maybe);\n }\n return result;\n }\n static void Set(Json& json, const std::vector& value) {\n json = Json::array();\n for (const auto& v : value) {\n Json vjson;\n ::nvidia::isaac::serialization::Set(vjson, v);\n json.push_back(vjson);\n }\n }\n};\n\n// For std::array\ntemplate \nstruct JsonSerializer> {\n static std::optional> TryGet(const Json& json) {\n if (!json.is_array()) {\n return std::nullopt;\n }\n if (json.size() != N) {\n return std::nullopt;\n }\n std::array result;\n for (size_t i = 0; i < N; i++) {\n auto maybe = ::nvidia::isaac::serialization::TryGet(json[i]);\n if (!maybe) {\n return std::nullopt;\n }\n result[i] = *maybe;\n }\n return result;\n }\n static void Set(Json& json, const std::array& value) {\n json = Json::array();\n // TODO reserve\n for (const auto& v : value) {\n Json vjson;\n ::nvidia::isaac::serialization::Set(vjson, v);\n json.push_back(vjson);\n }\n }\n};\n\n// For std::pair\ntemplate \nstruct JsonSerializer> {\n static std::optional> TryGet(const Json& json) {\n if (!json.is_array()) {\n return std::nullopt;\n }\n if (json.size() != 2) {\n return std::nullopt;\n }\n auto maybe1 = ::nvidia::isaac::serialization::TryGet(json[0]);\n if (!maybe1) {\n return std::nullopt;\n }\n auto maybe2 = ::nvidia::isaac::serialization::TryGet(json[1]);\n if (!maybe2) {\n return std::nullopt;\n }\n return std::pair{*maybe1, *maybe2};\n }\n static void Set(Json& json, const std::pair& value) {\n Json value1;\n ::nvidia::isaac::serialization::Set(value1, value.first);\n Json value2;\n ::nvidia::isaac::serialization::Set(value2, value.second);\n json = Json::array({value1, value2});\n }\n};\n\n// For std::map\n// Supporting general std::map would require array json, which we want to avoid for the time\n// being\ntemplate \nstruct JsonSerializer> {\n static std::optional> TryGet(const Json& json) {\n if (!json.is_object()) {\n return std::nullopt;\n }\n std::map result;\n for (const auto& val : json.items()) {\n auto maybe = ::nvidia::isaac::serialization::TryGet(val.value());\n if (!maybe) {\n return std::nullopt;\n }\n result.emplace(val.key(), *maybe);\n }\n return result;\n }\n static void Set(Json& json, const std::map& value) {\n json = Json::object();\n for (const auto& v : value) {\n json.emplace(v.first, v.second);\n }\n }\n};\n\n// Parameter support for SO3. It uses doubles to store elements in the json.\ntemplate \nstruct JsonSerializer> {\n // Tries to get pose in two ways. The first method is kept for backward compatibility.\n static std::optional> TryGet(const Json& json) {\n // First method for backward compatibility.\n // Expected four elements are (w, x, y, z) values for the quaternion.\n // Example: [0.0, 0.0, 0.0, 1.0]\n if (json.is_array()) {\n auto maybe = JsonSerializer>::TryGet(json);\n if (!maybe) {\n return std::nullopt;\n }\n const auto& array = *maybe;\n return SO3::FromQuaternion(Quaternion{array[0], array[1], array[2], array[3]});\n }\n\n // Second method for convenience.\n // Rotation can set by one of:\n // { \"axis\": [x, y, z], \"angle_radians\": a }\n // { \"axis\": [x, y, z], \"angle_degrees\": a }\n // { \"roll_radians\": r, \"pitch_radians\": p, \"yaw_radians\": y }\n // { \"roll_degrees\": r, \"pitch_degrees\": p, \"yaw_degrees\": y }\n // { \"qx\": x, \"qy\": y, \"qz\": z, \"qw\": w }\n\n // We'll demand one and only one way to be used.\n size_t num_rotation_ways_set = 0;\n // If error message gets populated, this function will return null.\n // This variable will help us prioritize num_rotation_ways_set check when printing an error.\n std::string error_message;\n SO3 rotation = SO3::Identity();\n\n // { \"axis\": [x, y, z], \"angle_radians\": a }\n // { \"axis\": [x, y, z], \"angle_degrees\": a }\n auto maybe_axis = TryGetFromMap>(json, \"axis\");\n auto maybe_angle = TryGetAngleInRadiansFromMap(json, \"angle\");\n if (maybe_axis || maybe_angle) {\n num_rotation_ways_set++;\n if (maybe_angle && maybe_axis) {\n rotation = SO3::FromAngleAxis(*maybe_angle, *maybe_axis);\n } else {\n error_message = \"Both \\\"axis\\\" and \\\"angle\\\" need to be set.\";\n }\n }\n\n // { \"roll_radians\": r, \"pitch_radians\": p, \"yaw_radians\": y }\n // { \"roll_degrees\": r, \"pitch_degrees\": p, \"yaw_degrees\": y }\n auto maybe_roll = TryGetAngleInRadiansFromMap(json, \"roll\");\n auto maybe_pitch = TryGetAngleInRadiansFromMap(json, \"pitch\");\n auto maybe_yaw = TryGetAngleInRadiansFromMap(json, \"yaw\");\n if (maybe_roll || maybe_pitch || maybe_yaw) {\n num_rotation_ways_set++;\n if (!maybe_roll) maybe_roll = 0.0;\n if (!maybe_pitch) maybe_pitch = 0.0;\n if (!maybe_yaw) maybe_yaw = 0.0;\n rotation = SO3::FromEulerAnglesRPY(*maybe_roll, *maybe_pitch, *maybe_yaw);\n }\n\n // { \"qx\": x, \"qy\": y, \"qz\": z, \"qw\": w }\n auto maybe_qx = TryGetFromMap(json, \"qx\");\n auto maybe_qy = TryGetFromMap(json, \"qy\");\n auto maybe_qz = TryGetFromMap(json, \"qz\");\n auto maybe_qw = TryGetFromMap(json, \"qw\");\n if (maybe_qx || maybe_qy || maybe_qz || maybe_qw) {\n num_rotation_ways_set++;\n if (maybe_qx && maybe_qy && maybe_qz && maybe_qw) {\n rotation =\n SO3::FromQuaternion(Quaternion{*maybe_qw, *maybe_qx, *maybe_qy, *maybe_qz});\n } else {\n error_message = \"\\\"qx\\\", \\\"qy\\\", \\\"qz\\\" and \\\"qw\\\" all need to be set.\";\n }\n }\n\n // check that only one way is used.\n if (num_rotation_ways_set != 1) {\n LOG_ERROR(\"Rotation can be one of:\");\n LOG_ERROR(\"{ \\\"axis\\\": [x, y, z], \\\"angle\\\": a }\");\n LOG_ERROR(\"{ \\\"roll\\\": r, \\\"pitch\\\": p, \\\"yaw\\\": y }\");\n LOG_ERROR(\"{ \\\"qx\\\": x, \\\"qy\\\": y, \\\"qz\\\": z, \\\"qw\\\": w }\");\n LOG_ERROR(\"Please set one and only one of them.\");\n\n return std::nullopt;\n }\n\n // If we had an issue, print the error and return null\n if (!error_message.empty()) {\n LOG_ERROR(error_message.c_str());\n return std::nullopt;\n }\n\n return rotation;\n }\n static void Set(Json& json, const SO3& value) {\n json = Json(std::array{\n {value.quaternion().w(), value.quaternion().x(), value.quaternion().y(),\n value.quaternion().z()}});\n }\n};\n\n// Parameter support for NSphere (where N is the dimension of the sphere)\n// Input serialization formats\n// In order of priority TryGet() will look in \"json\" for:\n// (1) A std::pair for which the first component contains an array of N numbers which represent\n// the center coordinates of the NSphere and the second component contains a single scalar\n// value representing the radius of the NSphere.\n// Ex. Json json = {{1.0, 2.0}, 3.0};\n// represents a circle with center (1.0, 2.0) and radius 3.0\n// (2) A Json object named \"center\" containing an array of N numbers which represent the center\n// coordinates of the NSphere AND a Json object named \"radius\" containing a single scalar\n// value representing the radius of the NSphere\n// Ex. Json json;\n// json[\"center\"] = {1.0, 2.0, 3.0};\n// json[\"radius\"] = 4.0;\n// represents a sphere with center (1.0, 2.0, 3.0) and radius 4.0\n// If neither format is available, std::nullopt will be returned.\n// Output serialization format:\n// A std::pair for which the first component contains an array of N numbers which represent the\n// center coordinates of the NSphere and the second component contains a single scalar value\n// representing the radius of the NSphere.\ntemplate \nstruct JsonSerializer> {\n using Sphere_t = geometry::NSphere;\n using Vector_t = typename geometry::NSphere::Vector_t;\n using Scalar_t = typename geometry::NSphere::Scalar;\n static std::optional TryGet(const Json& json) {\n // Try to get NSphere from format: {center_vector, radius_scalar}\n auto maybe = JsonSerializer>::TryGet(json);\n if (maybe) {\n return Sphere_t{maybe->first, maybe->second};\n }\n\n // Try to get NSphere from named attributes for center and radius\n auto maybe_center = TryGetFromMap(json, \"center\");\n auto maybe_radius = TryGetFromMap(json, \"radius\");\n if (maybe_center && maybe_radius) {\n return Sphere_t{*maybe_center, *maybe_radius};\n }\n\n return std::nullopt;\n }\n static void Set(Json& json, const Sphere_t& value) {\n ::nvidia::isaac::serialization::Set(\n json, std::pair{value.center, value.radius});\n }\n};\n\n// Parameter support for NCuboid (where N is the dimension of the cuboid)\n// Input serialization formats\n// In order of priority TryGet() will look in \"json\" for:\n// (1) A std::array of length N, for which each component contains an the minimum and maximum\n// bound for the Nth dimension.\n// Ex. Json json = {{-1.0, 1.0}, {-2.0, 2.0}};\n// represents a rectangle with the x dimension spanning -1.0 to 1.0 and the y dimension\n// spanning -2.0 to 2.0.\n// (2) A Json object named \"bounds\" containing an array of length the N, for which each\n// component contains an the minimum and maximum bound for that dimension.\n// Ex. Json json;\n// json[\"bounds\"] = {{-1.0, 1.0}, {-2.0, 2.0}};\n// represents a rectangle with the x dimension spanning -1.0 to 1.0 and the y dimension\n// spanning -2.0 to 2.0.\n// (3) A Json object named \"corner_1\" containing an array of length the N representing the\n// coordinates of one corner AND another Json object named \"corner_2\" containing an array of\n// length the N representing the coordinates of the opposite corner.\n// Ex. Json json;\n// json[\"corner_1\"] = {-1.0, -2.0};\n// json[\"corner_2\"] = { 1.0, 2.0};\n// represents a rectangle with the x dimension spanning -1.0 to 1.0 and the y dimension\n// spanning -2.0 to 2.0.\n// (4) A Json object named \"center\" containing an array of length the N representing the\n// coordinates of the center of the NCuboid AND another Json object named \"dimensions\"\n// containing an array of length the N representing the length of each dimension.\n// Ex. Json json;\n// json[\"center\"] = {0.0, 0.0};\n// json[\"dimension\"] = {2.0, 4.0};\n// represents a rectangle with the x dimension spanning -1.0 to 1.0 and the y dimension\n// spanning -2.0 to 2.0.\n// If none of these formats are available, std::nullopt will be returned.\n// Output serialization format:\n// A std::array of length N, for which each component contains an the minimum and maximum\n// bound for the Nth dimension.\ntemplate \nstruct JsonSerializer> {\n using Cube_t = geometry::NCuboid;\n using Vector_t = typename geometry::NCuboid::Vector_t;\n using Vector2K = Vector;\n using ArrayNVector2K = std::array;\n static std::optional TryGet(const Json& json) {\n // Try to get NCuboid from bounding cuboid format:\n // {{min_dim_0, max_dim_0}, {min_dim_1, max_dim_1}, ... {min_dim_N, max_dim_N}}\n auto maybe = JsonSerializer>::TryGet(json);\n if (maybe) {\n return Cube_t::FromBoundingCuboid(*maybe);\n }\n\n // Try to get NCuboid from named bounds\n auto maybe_bounds = TryGetFromMap(json, \"bounds\");\n if (maybe_bounds) {\n return Cube_t::FromBoundingCuboid(*maybe_bounds);\n }\n\n // Try to get NCuboid from named opposite corners\n auto maybe_corner_1 = TryGetFromMap(json, \"corner_1\");\n auto maybe_corner_2 = TryGetFromMap(json, \"corner_2\");\n if (maybe_corner_1 && maybe_corner_2) {\n return Cube_t::FromOppositeCorners(*maybe_corner_1, *maybe_corner_2);\n }\n\n // Try to get NCuboid from named center and dimensions\n auto maybe_center = TryGetFromMap(json, \"center\");\n auto maybe_dimensions = TryGetFromMap(json, \"dimensions\");\n if (maybe_center && maybe_dimensions) {\n return Cube_t::FromSizes(*maybe_center, *maybe_dimensions);\n }\n\n return std::nullopt;\n }\n static void Set(Json& json, const Cube_t& value) {\n ArrayNVector2K bounds;\n for (size_t dim = 0; dim < N; dim++) {\n bounds[dim] = Vector2K(value.min()[dim], value.max()[dim]);\n }\n ::nvidia::isaac::serialization::Set(json, ArrayNVector2K{bounds});\n }\n};\n\n// Parameter support for LineSegment\n// Input serialization formats\n// In order of priority TryGet() will look in \"json\" for:\n// (1) A std::pair for which the first component contains an array of N numbers which represent\n// the coordinates of the first endpoint and the second component contains an array of N\n// numbers which represent the coordinates of the second endpoint.\n// Ex. Json json = {{1.0, 2.0}, {3.0, 4.0}};\n// represents a 2D line segment spanning from (1.0, 2.0) to (3.0, 4.0).\n// (2) A Json object named \"point_1\" containing an array of N numbers which represent the\n// coordinates of the first endpoint AND a Json object named \"point_2\" containing an array\n// of N numbers which represent the coordinates of the second endpoint.\n// Ex. Json json;\n// json[\"point_1\"] = {1.0, 2.0};\n// json[\"point_2\"] = {3.0, 4.0};\n// represents a 2D line segment spanning from (1.0, 2.0) to (3.0, 4.0).\n// If neither format is available, std::nullopt will be returned.\n// Output serialization format:\n// A std::pair for which the first component contains an array of N numbers which represent the\n// coordinates of the first endpoint and the second component contains an array of N numbers which\n// represent the coordinates of the second endpoint.\ntemplate \nstruct JsonSerializer> {\n using LineSegment_t = geometry::LineSegment;\n using Vector_t = typename geometry::LineSegment::Vector_t;\n static std::optional TryGet(const Json& json) {\n // Try to get LineSegment from format: {point_1_vector, point_2_vector}\n auto maybe = JsonSerializer>::TryGet(json);\n if (maybe) {\n return LineSegment_t{maybe->first, maybe->second};\n }\n\n // Try to get LineSegment from named attributes for point_1 and point_2\n auto maybe_point_1 = TryGetFromMap(json, \"point_1\");\n auto maybe_point_2 = TryGetFromMap(json, \"point_2\");\n if (maybe_point_1 && maybe_point_2) {\n return LineSegment_t{*maybe_point_1, *maybe_point_2};\n }\n\n return std::nullopt;\n }\n static void Set(Json& json, const LineSegment_t& value) {\n ::nvidia::isaac::serialization::Set(json, std::pair{value.a(), value.b()});\n }\n};\n\n// Parameter support for Pose3. It uses doubles to store elements in the json.\ntemplate \nstruct JsonSerializer> {\n // Tries to get pose in two ways. The first method is kept for backward compatibility.\n static std::optional> TryGet(const Json& json) {\n // First method for backward compatibility.\n // First four elements are (w, x, y, z) values for the quaternion.\n // Last three elements are (x, y, z) locations.\n // Example: [0.0, 0.0, 0.0, 1.0, 25.0, 20.0, 0.0]\n if (json.is_array()) {\n auto maybe = JsonSerializer>::TryGet(json);\n if (!maybe) {\n return std::nullopt;\n }\n const auto& array = *maybe;\n return Pose3{\n SO3::FromQuaternion(Quaternion{array[0], array[1], array[2], array[3]}),\n Vector3{array[4], array[5], array[6]}};\n }\n\n // Second method for convenience.\n // User can supply a translation. If not supplied, zero translation will be used.\n // User can also supply a rotation. If not supplied, identity matrix (zero rotation) will be\n // used.\n // The expected format is:\n // {\n // \"translation\": [x, y, z],\n // \"rotation\": R\n // }\n // where acceptable formats for R are listed in SO3 serialization.\n Vector3 translation =\n GetFromMapOrDefault>(json, \"translation\", Vector3::Zero());\n SO3 rotation = GetFromMapOrDefault>(json, \"rotation\", SO3::Identity());\n return Pose3{rotation, translation};\n }\n static void Set(Json& json, const Pose3& value) {\n json = Json(std::array{\n {value.rotation.quaternion().w(), value.rotation.quaternion().x(),\n value.rotation.quaternion().y(), value.rotation.quaternion().z(), value.translation.x(),\n value.translation.y(), value.translation.z()}});\n }\n};\n\n// Parameter support for Pose2. It uses doubles to store elements in the json.\ntemplate \nstruct JsonSerializer> {\n static std::optional> TryGet(const Json& json) {\n auto maybe = JsonSerializer>::TryGet(json);\n if (!maybe) {\n return std::nullopt;\n }\n const auto& array = *maybe;\n return Pose2{SO2::FromAngle(array[0]), Vector2{array[1], array[2]}};\n }\n static void Set(Json& json, const Pose2& value) {\n json = Json(\n std::array{{value.rotation.angle(), value.translation.x(), value.translation.y()}});\n }\n};\n\n// Helper function to validate json color inputs for Pixel3ub and Pixel4ub\ninline bool ValidateColorInput(const std::vector& color_array) {\n if (!(color_array.size() == 3 || color_array.size() == 4)) {\n LOG_WARNING(\"Color must have three (RGB) or four (RGBA) components\");\n return false;\n }\n for (int component : color_array) {\n if (!(component >= 0 && component <= 255)) {\n LOG_WARNING(\"Color component must be in range 0-255\");\n return false;\n }\n }\n return true;\n}\n\n// Parameter support for Pixel3ub. It uses uint8_t to store elements in the json.\ntemplate <>\nstruct JsonSerializer {\n static std::optional TryGet(const Json& json) {\n auto maybe = JsonSerializer>::TryGet(json);\n if (!maybe) {\n return std::nullopt;\n }\n const auto& array = *maybe;\n if (ValidateColorInput(array)) {\n return Pixel3ub{\n static_cast(array[0]),\n static_cast(array[1]),\n static_cast(array[2]),\n };\n } else {\n LOG_WARNING(\"Invalid color input\");\n return std::nullopt;\n }\n }\n static void Set(Json& json, const Pixel3ub& value) {\n json = Json(std::array{{value[0], value[1], value[2]}});\n }\n};\n\n// Parameter support for Pixel4ub. It uses uint8_t to store elements in the json.\ntemplate <>\nstruct JsonSerializer {\n static std::optional TryGet(const Json& json) {\n auto maybe = JsonSerializer>::TryGet(json);\n if (!maybe) {\n return std::nullopt;\n }\n auto& array = *maybe;\n if (ValidateColorInput(array)) {\n // Add opaque alpha channel if not supplied in Json file\n if (array.size() == 3) {\n array.push_back(255);\n }\n\n return Pixel4ub{\n static_cast(array[0]), static_cast(array[1]),\n static_cast(array[2]), static_cast(array[3])};\n } else {\n LOG_WARNING(\"Invalid color input\");\n return std::nullopt;\n }\n }\n static void Set(Json& json, const Pixel4ub& value) {\n json = Json(std::array{{value[0], value[1], value[2], value[3]}});\n }\n};\n\n} // namespace json_formatter_details\n\ntemplate \nstd::optional TryGet(const Json& json) {\n return json_formatter_details::JsonSerializer::TryGet(json);\n}\n\ntemplate \nvoid Set(Json& json, T value) {\n json_formatter_details::JsonSerializer::Set(json, std::move(value));\n}\n\n} // namespace serialization\n} // namespace isaac\n} // namespace nvidia\n\nnamespace Eigen {\n\n// Conversion from Eigen types like Vector2d to Json\ntemplate \nvoid to_json(nlohmann::json& json, const T& value) {\n ::nvidia::isaac::serialization::Set(json, value);\n}\n\n// Conversion from Json to Eigen types like Vector2d\ntemplate \nvoid from_json(const nlohmann::json& json, T& value) {\n if (auto maybe = ::nvidia::isaac::serialization::TryGet(json)) {\n value = *maybe;\n }\n}\n\n} // namespace Eigen\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/sight/sop.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"gems/sight/sop_geometry.hpp\"\n#include \"gems/sight/sop_serializer.hpp\"\n#include \"gems/sight/sop_style.hpp\"\n#include \"gems/sight/sop_transform.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace sight {\n\n// Contains sight operation as a Tree structure:\n// - Each internal node contains a potential style (default for its children), a transformation to\n// apply before rendering the children\n// - Each leaf contains a simple primitive (or SopImage) to be rendered using the current default\n// style and using the composition of all the transformation above.\nclass Sop : public SopSerializer {\n public:\n // Simple constructor\n Sop() = default;\n Sop(Sop&&) = default;\n Sop(const Sop&) = delete;\n\n // Add a SopSerializer\n Sop(SopSerializer* sop) {\n list_.emplace_back(sop);\n }\n\n // Add a primitive without a transform or style\n template , int> = 0>\n void add(Primitive primitive) {\n list_.emplace_back(new Primitive(std::move(primitive)));\n }\n\n // Add a primitive with a given transform\n template , int> = 0>\n void add(Primitive primitive, const SopTransform& transform) {\n Sop* sop = new Sop(new Primitive(std::move(primitive)));\n sop->transform = transform;\n list_.emplace_back(static_cast(sop));\n }\n\n // Add a primitive with a given style\n template , int> = 0>\n void add(Primitive primitive, const SopStyle& style) {\n Sop* sop = new Sop(new Primitive(std::move(primitive)));\n sop->style = style;\n list_.emplace_back(static_cast(sop));\n }\n\n // Add a primitive with a given transform and style\n template , int> = 0>\n void add(Primitive primitive, const SopStyle& style, const SopTransform& transform) {\n Sop* sop = new Sop(new Primitive(std::move(primitive)));\n sop->style = style;\n sop->transform = transform;\n list_.emplace_back(static_cast(sop));\n }\n\n // Add a primitive with a given transform\n template \n void add(const Args&... args) {\n list_.emplace_back(new Primitive(args...));\n }\n\n // Add a primitive with a given transform\n template \n void add(const SopTransform& transform, const Args&... args) {\n Sop* sop = new Sop(new Primitive(args...));\n sop->transform = transform;\n list_.emplace_back(static_cast(sop));\n }\n\n // Add a primitive with a given style\n template \n void add(const SopStyle& style, const Args&... args) {\n Sop* sop = new Sop(new Primitive(args...));\n sop->style = style;\n list_.emplace_back(static_cast(sop));\n }\n\n // Add a primitive with a given transform and style\n template \n void add(const SopStyle& style, const SopTransform& transform, const Args&... args) {\n Sop* sop = new Sop(new Primitive(args...));\n sop->style = style;\n sop->transform = transform;\n list_.emplace_back(static_cast(sop));\n }\n\n template , int> = 0>\n void add(F f) {\n Sop* sop = new Sop();\n f(*sop);\n list_.emplace_back(static_cast(sop));\n }\n\n // Make a sop static, it will be rendered at the latest time from the PoseTree.\n void makeStatic();\n\n uint8_t key() const;\n\n bool toBinary(BufferSerialization& buffer) const override;\n\n bool fromBinary(BufferSerialization& buffer) override;\n\n // Optional style to be apply to the children\n std::optional style;\n // Optional transformation to apply to the the subtree\n std::optional transform;\n\n private:\n bool static_ = false;\n std::vector> list_;\n};\n\n} // namespace sight\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/sight/sop_asset.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/sight/sop_serializer.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace sight {\n\n// Sight Operation Asset.\n// TODO(bbutin): Right it now it contains only a name to an asset, later we need to add information\n// about the asset as well.\nclass SopAsset : public SopSerializer {\n public:\n // Creates empty SopAsset\n SopAsset() = default;\n SopAsset(SopAsset&&) = default;\n ~SopAsset() override = default;\n\n // Creates an asset with a name\n SopAsset(std::string text);\n\n // Construct a sop by calling fromBinary\n SopAsset(BufferSerialization& buffer);\n\n bool toBinary(BufferSerialization& buffer) const override;\n bool fromBinary(BufferSerialization& buffer) override;\n\n private:\n std::string name_ = \"\";\n};\n\n} // namespace sight\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/sight/sop_image.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/image/image.hpp\"\n#include \"gems/core/math/types.hpp\"\n#include \"gems/image/io.hpp\"\n#include \"gems/sight/sop_serializer.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace sight {\n\n// Sight Operation Image.\n// Helper to serialize an image in JPG (default) or PNG format\nclass SopImage : public SopSerializer {\n public:\n // Creates empty image\n SopImage() = default;\n SopImage(SopImage&&) = default;\n ~SopImage() override = default;\n\n // Create an image in png or jpg format and whether or not you flip it.\n template \n SopImage(const Image& img, bool png, bool flip) {\n if (!img.empty()) {\n flip_ = flip;\n if (png) {\n ::nvidia::isaac::EncodePng(img, image_);\n } else {\n ::nvidia::isaac::EncodeJpeg(img, /* quality = */ 50, image_);\n }\n }\n }\n\n // Create an image in png or jpg format.\n template \n SopImage(const Image& img, bool png) {\n if (!img.empty()) {\n flip_ = false;\n if (png) {\n ::nvidia::isaac::EncodePng(img, image_);\n } else {\n ::nvidia::isaac::EncodeJpeg(img, /* quality = */ 50, image_);\n }\n }\n }\n\n // Create an image in jpg format with a custom quality.\n template \n static SopImage Jpg(const Image& img, int quality) {\n SopImage sop;\n if (!img.empty()) {\n sop.flip_ = false;\n ::nvidia::isaac::EncodeJpeg(img, quality, sop.image_);\n }\n return sop;\n }\n\n // Create an image in jpg format with a custom quality and whether or not you flip it.\n template \n static SopImage Jpg(const Image& img, int quality, bool flip) {\n SopImage sop;\n if (!img.empty()) {\n sop.flip_ = flip;\n ::nvidia::isaac::EncodeJpeg(img, quality, sop.image_);\n }\n return sop;\n }\n\n // Create an image in jpg format.\n template \n SopImage(const Image& img) {\n if (!img.empty()) {\n flip_ = false;\n ::nvidia::isaac::EncodeJpeg(img, 50, image_);\n }\n }\n\n // Construct a sop by calling fromBinary\n SopImage(BufferSerialization& buffer);\n\n bool toBinary(BufferSerialization& buffer) const override;\n bool fromBinary(BufferSerialization& buffer) override;\n\n private:\n bool flip_;\n std::vector image_;\n};\n\n} // namespace sight\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/sight/sop_mesh.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/math/types.hpp\"\n#include \"gems/sight/sop_serializer.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace sight {\n\n// Sight Operation for a mesh.\nclass SopMesh : public SopSerializer {\n public:\n SopMesh() = default;\n SopMesh(SopMesh&&) = default;\n ~SopMesh() override = default;\n\n // Creates a new SopMesh, `append` indicates whether or not it's an update or if we should restart\n // from scratch.\n SopMesh(bool append);\n\n // Adds a new block to the mesh.\n // Parameters:\n // - name: the name of the block.\n // - num_points: the number of points (N)\n // - points: a vector of coordinates, size 3N, contains [x0,y0,z0, x1,y1,z1, ...,]\n // - num_triangles: the number of triangles, (M)\n // - triangles: indices of points that form a triangle, size 3M, the first three indices\n // correspond to the first triangle, the next three to the second triangle, and so on\n // - colors: if not null, it contains the color of each point in order. The format is RGB.\n // - normals: if not null, it contains the normal vector of each point, [nx0,ny0,nz0, ...]\n void add(std::string name, int num_points, const float* points, int num_triangles,\n const uint16_t* triangles, const uint8_t* colors = nullptr,\n const float* normals = nullptr);\n void add(std::string name, std::vector points, std::vector triangles,\n std::vector colors, std::vector normals);\n\n // Construct a sop by calling fromBinary\n SopMesh(BufferSerialization& buffer);\n\n bool toBinary(BufferSerialization& buffer) const override;\n bool fromBinary(BufferSerialization& buffer) override;\n\n private:\n // Hold the information about a single block.\n struct Block {\n std::string name;\n std::vector points;\n std::vector normals;\n std::vector colors;\n std::vector triangles;\n };\n\n bool append_ = true;\n std::list blocks_;\n};\n\n} // namespace sight\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/sight/sop_point_cloud.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n\n#include \"gems/core/math/types.hpp\"\n#include \"gems/core/tensor/sample_cloud.hpp\"\n#include \"gems/sight/sop_serializer.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace sight {\n\n// Sight show operation for point clouds.\nclass SopPointCloud : public SopSerializer {\n public:\n SopPointCloud() = default;\n SopPointCloud(SopPointCloud&&) = default;\n ~SopPointCloud() override = default;\n\n // Creates a SopPointCloud with 2d points\n SopPointCloud(::nvidia::isaac::SampleCloudConstView2f points, int downsample_stride = 1);\n SopPointCloud(::nvidia::isaac::SampleCloudConstView2f points,\n ::nvidia::isaac::SampleCloudConstView3ub colors,\n int downsample_stride = 1);\n\n // Creates a SopPointCloud with 3d points\n SopPointCloud(::nvidia::isaac::SampleCloudConstView3f points, int downsample_stride = 1);\n SopPointCloud(::nvidia::isaac::SampleCloudConstView3f points,\n ::nvidia::isaac::SampleCloudConstView3ub colors,\n int downsample_stride = 1);\n\n // Construct a sop by calling fromBinary\n SopPointCloud(BufferSerialization& buffer);\n\n bool toBinary(BufferSerialization& buffer) const override;\n bool fromBinary(BufferSerialization& buffer) override;\n\n private:\n int dim_ = 0;\n std::vector pts_;\n std::vector colors_;\n};\n\n} // namespace sight\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/sight/sop_style.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/image/image.hpp\"\n#include \"gems/sight/sop_serializer.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace sight {\n\n// Sight Operation Style\n// Contains optional information to apply to the sight operation\nstruct SopStyle : public SopSerializer {\n // Creates empty style\n SopStyle() = default;\n ~SopStyle() override = default;\n\n // Creates a style with a color (valid javascript format: e.g. '#abc' '#123456' 'rgb(0, 1, 2)',\n // 'white', etc...)\n SopStyle(std::string color);\n SopStyle(const char* color);\n SopStyle(const ::nvidia::isaac::Pixel3ub& col);\n SopStyle(const ::nvidia::isaac::Pixel4ub& col);\n\n // Helper == operator for testing deserialize.\n bool operator==(const SopStyle& style) const;\n\n // Creates a style with a color and whether object should be filled or not.\n template \n SopStyle(const C& color, bool fill) : SopStyle(color) {\n fill_ = fill;\n }\n\n // Creates a style with a color, whether object should be filled or not, and a default size.\n template \n SopStyle(const C& color, bool fill, double size) : SopStyle(color, fill) {\n size_ = size;\n }\n\n // Creates a style with a color, whether object should be filled or not, a default size, and an\n // alpha value to control transparency. If a Pixel4ub is provided for color, it's alpha component\n // will be overwritten by the alpha value provided as a double.\n template \n SopStyle(const C& color, bool fill, double size, double alpha) : SopStyle(color, fill, size) {\n alpha_ = static_cast(std::clamp(256.0 * alpha, 0.0, 255.0));\n }\n\n bool toBinary(BufferSerialization& buffer) const override;\n\n bool fromBinary(BufferSerialization& buffer) override;\n\n private:\n std::optional color_str_;\n std::optional<::nvidia::isaac::Pixel3ub> color_;\n std::optional alpha_;\n std::optional fill_;\n std::optional size_;\n};\n\n} // namespace sight\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/sight/sop_text.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/math/types.hpp\"\n#include \"gems/sight/sop_serializer.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace sight {\n\n// Sight Operation Text\n// Can be used to display text at a given position\nclass SopText : public SopSerializer {\n public:\n // Creates empty SopText\n SopText() = default;\n SopText(SopText&&) = default;\n ~SopText() override = default;\n\n // Creates a text with not other information (will be rendered at (0, 0))\n SopText(std::string text);\n\n // Creates a style with a color and wether object should be filled or not.\n template \n SopText(std::string text, const ::nvidia::isaac::Vector2& pos) : SopText(std::move(text)) {\n position_ = pos.template cast();\n }\n\n // Creates a SopText setup to center the text.\n template \n SopText(std::string text, const ::nvidia::isaac::Vector2& pos, bool center)\n : SopText(std::move(text), pos) {\n center_ = center;\n }\n\n // Construct a sop by calling fromBinary\n SopText(BufferSerialization& buffer);\n\n bool toBinary(BufferSerialization& buffer) const override;\n bool fromBinary(BufferSerialization& buffer) override;\n\n private:\n std::string text_ = \"\";\n bool center_ = false;\n std::optional<::nvidia::isaac::Vector2f> position_;\n};\n\n} // namespace sight\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/sight/sop_transform.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \n\n#include \"gems/core/math/pose2.hpp\"\n#include \"gems/core/math/pose3.hpp\"\n#include \"gems/geometry/pinhole.hpp\"\n#include \"gems/sight/sop_serializer.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\nnamespace sight {\n\n// Sight Operation Transform\n// Contains the Pose2 or Pose3 transform or frame as well as a scale factor and a pinhole model.\nstruct SopTransform : public SopSerializer {\n // Creates empty transform\n SopTransform() = default;\n ~SopTransform() override = default;\n\n // Creates a SopTransform using the canvas pixel frame (allow you to draw directly at a given\n // position on a canvas).\n // Note: this only works for 2D and the Sop will not be rendered in 3D.\n static SopTransform CanvasFrame();\n\n // Creates a SopTransform using a reference frame from uid\n SopTransform(uint64_t uid);\n\n // Creates a SopTransform using a reference frame\n SopTransform(const std::string& reference_frame);\n\n // Creates a SopTransform using a Pose2\n template \n SopTransform(const ::nvidia::isaac::Pose2& pose) {\n pose2_ = pose.template cast();\n }\n\n // Creates a SopTransform using a Pose3\n template \n SopTransform(const ::nvidia::isaac::Pose3& pose) {\n pose3_ = pose.template cast();\n }\n\n // Creates a transform with a Pose and a scale\n template \n SopTransform(const Pose& pose, double scale) : SopTransform(pose) {\n scale_ = scale;\n }\n\n // Creates a transform with a Pose and a pinhole projection\n template \n SopTransform(const Pose& pose, const ::nvidia::isaac::geometry::Pinhole& pinhole)\n : SopTransform(pose) {\n pinhole_ = pinhole.template cast();\n }\n\n // Creates a transform with a Pose and a scale\n template \n SopTransform(const Pose& pose, double scale, const ::nvidia::isaac::geometry::Pinhole& pinhole)\n : SopTransform(pose, pinhole) {\n scale_ = scale;\n }\n\n // Helper == operator for testing deserialize.\n bool operator==(const SopTransform& style) const;\n\n bool toBinary(BufferSerialization& buffer) const override;\n\n bool fromBinary(BufferSerialization& buffer) override;\n\n private:\n bool canvas_ = false;\n std::optional uid_;\n std::optional frame_;\n std::optional<::nvidia::isaac::Pose2f> pose2_;\n std::optional<::nvidia::isaac::Pose3f> pose3_;\n std::optional scale_;\n std::optional<::nvidia::isaac::geometry::Pinhole> pinhole_;\n};\n\n} // namespace sight\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/uuid/uuid.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n\nnamespace nvidia {\nnamespace isaac {\n\n// A universally unique identifier (UUID)\nclass Uuid {\n public:\n static constexpr int kNumBytes = 16;\n\n // Generates a new UUID\n static Uuid Generate();\n // Creates a UUID from a string. If the string has \"unparsed\" UUID format it will be parsed as a\n // UUID string. Otherwise it will be treated as an ASCII string. An unparsed UUID string has the\n // format \"XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\" with XXX alpha-numeric characters. May assert\n // if neither form of parsing succeeds, e.g. if the string is too long.\n static Uuid FromString(const std::string& str);\n // Parses a string as an ASCII string. Will assert if the string is too long.\n static Uuid FromAsciiString(const std::string& str);\n // Creates a UUID from a serialized UUID string. This will assert in case the string does not\n // have the right format.\n static Uuid FromUuidString(const std::string& str);\n // Creates UUID from two 64-bit integers\n static Uuid FromUInt64(uint64_t lower, uint64_t upper) {\n Uuid uuid;\n uuid.longs_[0] = lower;\n uuid.longs_[1] = upper;\n uuid.is_uuid_ = true; // FIXME\n return uuid;\n }\n\n // Creates an invalid (whatever that means) UUID with all 0\n Uuid() { longs_[0] = 0; longs_[1] = 0; is_uuid_ = false; }\n\n // Iterator interface\n const unsigned char* begin() const { return bytes_; }\n unsigned char* begin() { return bytes_; }\n const unsigned char* end() const { return bytes_ + kNumBytes; }\n unsigned char* end() { return bytes_ + kNumBytes; }\n\n uint64_t lower() const { return longs_[0]; }\n uint64_t upper() const { return longs_[1]; }\n\n // A hash value so that we can use the UUID as a key\n size_t hash() const {\n // Should be way faster than a string-based hash\n return lower() ^ upper();\n }\n\n // Gets an unparsed string representation for the UUID\n const std::string& str() const {\n if (str_.empty()) {\n unparse();\n }\n return str_;\n }\n // Same as str() but directly returns a null-terminated C-string\n const char* c_str() const {\n return str().c_str();\n }\n\n // Comparison operators\n friend bool operator==(const Uuid& lhs, const Uuid& rhs) {\n return lhs.lower() == rhs.lower() && lhs.upper() == rhs.upper();\n }\n friend bool operator!=(const Uuid& lhs, const Uuid& rhs) {\n return !(lhs == rhs);\n }\n friend bool operator<(const Uuid& lhs, const Uuid& rhs) {\n return lhs.upper() < rhs.upper()\n || (lhs.upper() == rhs.upper() && lhs.lower() < rhs.lower());\n }\n\n private:\n // Use both 8-bit unsigned and bytes representations\n union {\n unsigned char bytes_[kNumBytes];\n uint64_t longs_[2];\n };\n\n // True if this is actually a UUID and not a string chosen by the user.\n bool is_uuid_;\n\n // Cached string version of uuid used for printing\n mutable std::string str_;\n\n // Computes the unparsed string version of the UUID\n void unparse() const;\n};\n\n} // namespace isaac\n} // namespace nvidia\n\nnamespace std {\n\n// Overload for std::hash to be compatible with standard containers\ntemplate <>\nstruct hash {\n size_t operator()(const nvidia::isaac::Uuid& x) const {\n return x.hash();\n }\n};\n\n} // namespace std\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/video_buffer/allocator.hpp", "content": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n// http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing, software\n// distributed under the License is distributed on an \"AS IS\" BASIS,\n// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n// See the License for the specific language governing permissions and\n// limitations under the License.\n//\n// SPDX-License-Identifier: Apache-2.0\n#pragma once\n\n#include \n#include \n#include \"gxf/multimedia/video.hpp\"\n#include \"gxf/std/allocator.hpp\"\n\nnamespace nvidia {\nnamespace isaac {\n\ntemplate \nstruct NoPaddingColorPlanes {};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width) : planes({gxf::ColorPlane(\"RGB\", 3, width * 3)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"BGR\", 3, width * 3)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"RGBA\", 4, width * 4)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"BGRA\", 4, width * 4)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"RGB\", 6, width * 6)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"BGR\", 6, width * 6)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"RGB\", 12, width * 12)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"BGR\", 12, width * 12)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"gray\", 1, width)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"gray\", 2, width * 2)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"gray\", 4, width * 4)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"gray\", 4, width * 4)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"Y\", 1, width),\n nvidia::gxf::ColorPlane(\"UV\", 2, width)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"Y\", 1, width),\n nvidia::gxf::ColorPlane(\"UV\", 2, width)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"Y\", 1, width),\n nvidia::gxf::ColorPlane(\"UV\", 2, width * 2)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"Y\", 1, width),\n nvidia::gxf::ColorPlane(\"UV\", 2, width * 2)}) {}\n std::array planes;\n};\n\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes({gxf::ColorPlane(\"R\", 1, width), gxf::ColorPlane(\"G\", 1, width),\n gxf::ColorPlane(\"B\", 1, width)}) {}\n std::array planes;\n};\n\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes({gxf::ColorPlane(\"R\", 2, width * 2), gxf::ColorPlane(\"G\", 2, width * 2),\n gxf::ColorPlane(\"B\", 2, width * 2)}) {}\n std::array planes;\n};\n\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes(\n {gxf::ColorPlane(\"R\", 4, width * 4), gxf::ColorPlane(\"G\", 4, width * 4),\n gxf::ColorPlane(\"B\", 4, width * 4)}) {}\n std::array planes;\n};\n\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes({gxf::ColorPlane(\"B\", 1, width), gxf::ColorPlane(\"G\", 1, width),\n gxf::ColorPlane(\"R\", 1, width)}) {}\n std::array planes;\n};\n\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes(\n {gxf::ColorPlane(\"R\", 2, width * 2), gxf::ColorPlane(\"G\", 2, width * 2),\n gxf::ColorPlane(\"B\", 2, width * 2)}) {}\n std::array planes;\n};\n\ntemplate<>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(size_t width)\n : planes(\n {gxf::ColorPlane(\"B\", 4, width * 4), gxf::ColorPlane(\"G\", 4, width * 4),\n gxf::ColorPlane(\"R\", 4, width * 4)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"D\", 4, width * 4)}) {}\n std::array planes;\n};\n\ntemplate <>\nstruct NoPaddingColorPlanes {\n explicit NoPaddingColorPlanes(uint32_t width)\n : planes({nvidia::gxf::ColorPlane(\"D\", 8, width * 8)}) {}\n std::array planes;\n};\n\n// This includes the list of video buffer formats that supported for the allocator\nconstexpr bool IsSupportedVideoFormat(const gxf::VideoFormat format) {\n return format == gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_RGBA ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_BGRA ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY32F ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_B8_G8_R8 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_B16_G16_R16 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_B32_G32_R32 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_NV12 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_NV12_ER ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_NV24 ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_NV24_ER ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_D32F ||\n format == gxf::VideoFormat::GXF_VIDEO_FORMAT_D64F;\n}\n\ntemplate::type* = nullptr>\ngxf::Expected AllocateUnpaddedVideoBuffer(\n gxf::Handle frame, uint32_t width, uint32_t height,\n gxf::MemoryStorageType storage_type,\n gxf::Handle allocator) {\n GXF_LOG_ERROR(\"Received unsupported video format!\");\n return gxf::Unexpected{GXF_FAILURE};\n}\n\ntemplate::type* = nullptr>\ngxf::Expected AllocateUnpaddedVideoBuffer(\n gxf::Handle frame, uint32_t width, uint32_t height,\n gxf::MemoryStorageType storage_type, gxf::Handle allocator) {\n if (width % 2 != 0 || height % 2 != 0) {\n GXF_LOG_ERROR(\n \"Error: expected even width and height but received %u width and %u height\",\n width, height);\n return gxf::Unexpected{GXF_FAILURE};\n }\n NoPaddingColorPlanes nopadding_planes(width);\n gxf::VideoFormatSize video_format_size;\n auto size = video_format_size.size(width, height, nopadding_planes.planes);\n std::vector color_planes{\n nopadding_planes.planes.begin(), nopadding_planes.planes.end()};\n gxf::VideoBufferInfo buffer_info{width, height, T, color_planes,\n gxf::SurfaceLayout::GXF_SURFACE_LAYOUT_PITCH_LINEAR};\n return frame->resizeCustom(buffer_info, size, storage_type, allocator);\n}\n\ntemplate\ngxf::Expected AllocateVideoBuffer(\n gxf::Handle frame, uint32_t width, uint32_t height,\n gxf::SurfaceLayout layout, gxf::MemoryStorageType storage_type,\n gxf::Handle allocator) {\n return frame->resize(width, height, layout, storage_type, allocator);\n}\n\n} // namespace isaac\n} // namespace nvidia\n" }, { "path": "isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/third_party/nlohmann/json.hpp", "content": "// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n/****************************************************************************\\\n * Note on documentation: The source files contain links to the online *\n * documentation of the public API at https://json.nlohmann.me. This URL *\n * contains the most recent documentation and should also be applicable to *\n * previous versions; documentation for deprecated functions is not *\n * removed, but marked deprecated. See \"Generate documentation\" section in *\n * file docs/README.md. *\n\\****************************************************************************/\n\n#ifndef INCLUDE_NLOHMANN_JSON_HPP_\n#define INCLUDE_NLOHMANN_JSON_HPP_\n\n#include // all_of, find, for_each\n#include // nullptr_t, ptrdiff_t, size_t\n#include // hash, less\n#include // initializer_list\n#ifndef JSON_NO_IO\n #include // istream, ostream\n#endif // JSON_NO_IO\n#include // random_access_iterator_tag\n#include // unique_ptr\n#include // accumulate\n#include // string, stoi, to_string\n#include // declval, forward, move, pair, swap\n#include // vector\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// This file contains all macro definitions affecting or depending on the ABI\n\n#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK\n #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH)\n #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 2\n #warning \"Already included a different version of the library!\"\n #endif\n #endif\n#endif\n\n#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum)\n#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum)\n#define NLOHMANN_JSON_VERSION_PATCH 2 // NOLINT(modernize-macro-to-enum)\n\n#ifndef JSON_DIAGNOSTICS\n #define JSON_DIAGNOSTICS 0\n#endif\n\n#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON\n #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0\n#endif\n\n#if JSON_DIAGNOSTICS\n #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag\n#else\n #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS\n#endif\n\n#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON\n #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp\n#else\n #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON\n#endif\n\n#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION\n #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0\n#endif\n\n// Construct the namespace ABI tags component\n#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b\n#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \\\n NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b)\n\n#define NLOHMANN_JSON_ABI_TAGS \\\n NLOHMANN_JSON_ABI_TAGS_CONCAT( \\\n NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \\\n NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON)\n\n// Construct the namespace version component\n#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \\\n _v ## major ## _ ## minor ## _ ## patch\n#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \\\n NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch)\n\n#if NLOHMANN_JSON_NAMESPACE_NO_VERSION\n#define NLOHMANN_JSON_NAMESPACE_VERSION\n#else\n#define NLOHMANN_JSON_NAMESPACE_VERSION \\\n NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \\\n NLOHMANN_JSON_VERSION_MINOR, \\\n NLOHMANN_JSON_VERSION_PATCH)\n#endif\n\n// Combine namespace components\n#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b\n#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \\\n NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b)\n\n#ifndef NLOHMANN_JSON_NAMESPACE\n#define NLOHMANN_JSON_NAMESPACE \\\n nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \\\n NLOHMANN_JSON_ABI_TAGS, \\\n NLOHMANN_JSON_NAMESPACE_VERSION)\n#endif\n\n#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN\n#define NLOHMANN_JSON_NAMESPACE_BEGIN \\\n namespace nlohmann \\\n { \\\n inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \\\n NLOHMANN_JSON_ABI_TAGS, \\\n NLOHMANN_JSON_NAMESPACE_VERSION) \\\n {\n#endif\n\n#ifndef NLOHMANN_JSON_NAMESPACE_END\n#define NLOHMANN_JSON_NAMESPACE_END \\\n } /* namespace (inline namespace) NOLINT(readability/namespace) */ \\\n } // namespace nlohmann\n#endif\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // transform\n#include // array\n#include // forward_list\n#include // inserter, front_inserter, end\n#include // map\n#include // string\n#include // tuple, make_tuple\n#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible\n#include // unordered_map\n#include // pair, declval\n#include // valarray\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // nullptr_t\n#include // exception\n#include // runtime_error\n#include // to_string\n#include // vector\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // array\n#include // size_t\n#include // uint8_t\n#include // string\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // declval, pair\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\ntemplate struct make_void\n{\n using type = void;\n};\ntemplate using void_t = typename make_void::type;\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\n// https://en.cppreference.com/w/cpp/experimental/is_detected\nstruct nonesuch\n{\n nonesuch() = delete;\n ~nonesuch() = delete;\n nonesuch(nonesuch const&) = delete;\n nonesuch(nonesuch const&&) = delete;\n void operator=(nonesuch const&) = delete;\n void operator=(nonesuch&&) = delete;\n};\n\ntemplate class Op,\n class... Args>\nstruct detector\n{\n using value_t = std::false_type;\n using type = Default;\n};\n\ntemplate class Op, class... Args>\nstruct detector>, Op, Args...>\n{\n using value_t = std::true_type;\n using type = Op;\n};\n\ntemplate class Op, class... Args>\nusing is_detected = typename detector::value_t;\n\ntemplate class Op, class... Args>\nstruct is_detected_lazy : is_detected { };\n\ntemplate class Op, class... Args>\nusing detected_t = typename detector::type;\n\ntemplate class Op, class... Args>\nusing detected_or = detector;\n\ntemplate class Op, class... Args>\nusing detected_or_t = typename detected_or::type;\n\ntemplate class Op, class... Args>\nusing is_detected_exact = std::is_same>;\n\ntemplate class Op, class... Args>\nusing is_detected_convertible =\n std::is_convertible, To>;\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n\n\n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson \n// SPDX-License-Identifier: MIT\n\n/* Hedley - https://nemequ.github.io/hedley\n * Created by Evan Nemerson \n */\n\n#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15)\n#if defined(JSON_HEDLEY_VERSION)\n #undef JSON_HEDLEY_VERSION\n#endif\n#define JSON_HEDLEY_VERSION 15\n\n#if defined(JSON_HEDLEY_STRINGIFY_EX)\n #undef JSON_HEDLEY_STRINGIFY_EX\n#endif\n#define JSON_HEDLEY_STRINGIFY_EX(x) #x\n\n#if defined(JSON_HEDLEY_STRINGIFY)\n #undef JSON_HEDLEY_STRINGIFY\n#endif\n#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)\n\n#if defined(JSON_HEDLEY_CONCAT_EX)\n #undef JSON_HEDLEY_CONCAT_EX\n#endif\n#define JSON_HEDLEY_CONCAT_EX(a,b) a##b\n\n#if defined(JSON_HEDLEY_CONCAT)\n #undef JSON_HEDLEY_CONCAT\n#endif\n#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)\n\n#if defined(JSON_HEDLEY_CONCAT3_EX)\n #undef JSON_HEDLEY_CONCAT3_EX\n#endif\n#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c\n\n#if defined(JSON_HEDLEY_CONCAT3)\n #undef JSON_HEDLEY_CONCAT3\n#endif\n#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)\n\n#if defined(JSON_HEDLEY_VERSION_ENCODE)\n #undef JSON_HEDLEY_VERSION_ENCODE\n#endif\n#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))\n\n#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)\n #undef JSON_HEDLEY_VERSION_DECODE_MAJOR\n#endif\n#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)\n\n#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)\n #undef JSON_HEDLEY_VERSION_DECODE_MINOR\n#endif\n#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)\n\n#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)\n #undef JSON_HEDLEY_VERSION_DECODE_REVISION\n#endif\n#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)\n\n#if defined(JSON_HEDLEY_GNUC_VERSION)\n #undef JSON_HEDLEY_GNUC_VERSION\n#endif\n#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)\n #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)\n#elif defined(__GNUC__)\n #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)\n #undef JSON_HEDLEY_GNUC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_GNUC_VERSION)\n #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_MSVC_VERSION)\n #undef JSON_HEDLEY_MSVC_VERSION\n#endif\n#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL)\n #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)\n#elif defined(_MSC_FULL_VER) && !defined(__ICL)\n #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)\n#elif defined(_MSC_VER) && !defined(__ICL)\n #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)\n#endif\n\n#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)\n #undef JSON_HEDLEY_MSVC_VERSION_CHECK\n#endif\n#if !defined(JSON_HEDLEY_MSVC_VERSION)\n #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)\n#elif defined(_MSC_VER) && (_MSC_VER >= 1400)\n #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))\n#elif defined(_MSC_VER) && (_MSC_VER >= 1200)\n #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))\n#else\n #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))\n#endif\n\n#if defined(JSON_HEDLEY_INTEL_VERSION)\n #undef JSON_HEDLEY_INTEL_VERSION\n#endif\n#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL)\n #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)\n#elif defined(__INTEL_COMPILER) && !defined(__ICL)\n #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)\n#endif\n\n#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)\n #undef JSON_HEDLEY_INTEL_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_INTEL_VERSION)\n #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_INTEL_CL_VERSION)\n #undef JSON_HEDLEY_INTEL_CL_VERSION\n#endif\n#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL)\n #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0)\n#endif\n\n#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK)\n #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_INTEL_CL_VERSION)\n #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_PGI_VERSION)\n #undef JSON_HEDLEY_PGI_VERSION\n#endif\n#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)\n #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)\n#endif\n\n#if defined(JSON_HEDLEY_PGI_VERSION_CHECK)\n #undef JSON_HEDLEY_PGI_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_PGI_VERSION)\n #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_SUNPRO_VERSION)\n #undef JSON_HEDLEY_SUNPRO_VERSION\n#endif\n#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)\n #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)\n#elif defined(__SUNPRO_C)\n #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)\n#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)\n #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)\n#elif defined(__SUNPRO_CC)\n #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)\n#endif\n\n#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)\n #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_SUNPRO_VERSION)\n #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)\n #undef JSON_HEDLEY_EMSCRIPTEN_VERSION\n#endif\n#if defined(__EMSCRIPTEN__)\n #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)\n#endif\n\n#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)\n #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)\n #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_ARM_VERSION)\n #undef JSON_HEDLEY_ARM_VERSION\n#endif\n#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)\n #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)\n#elif defined(__CC_ARM) && defined(__ARMCC_VERSION)\n #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)\n#endif\n\n#if defined(JSON_HEDLEY_ARM_VERSION_CHECK)\n #undef JSON_HEDLEY_ARM_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_ARM_VERSION)\n #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_IBM_VERSION)\n #undef JSON_HEDLEY_IBM_VERSION\n#endif\n#if defined(__ibmxl__)\n #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)\n#elif defined(__xlC__) && defined(__xlC_ver__)\n #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)\n#elif defined(__xlC__)\n #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)\n#endif\n\n#if defined(JSON_HEDLEY_IBM_VERSION_CHECK)\n #undef JSON_HEDLEY_IBM_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_IBM_VERSION)\n #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_VERSION)\n #undef JSON_HEDLEY_TI_VERSION\n#endif\n#if \\\n defined(__TI_COMPILER_VERSION__) && \\\n ( \\\n defined(__TMS470__) || defined(__TI_ARM__) || \\\n defined(__MSP430__) || \\\n defined(__TMS320C2000__) \\\n )\n#if (__TI_COMPILER_VERSION__ >= 16000000)\n #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n#endif\n\n#if defined(JSON_HEDLEY_TI_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_VERSION)\n #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL2000_VERSION)\n #undef JSON_HEDLEY_TI_CL2000_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)\n #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CL2000_VERSION)\n #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL430_VERSION)\n #undef JSON_HEDLEY_TI_CL430_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)\n #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CL430_VERSION)\n #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)\n #undef JSON_HEDLEY_TI_ARMCL_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))\n #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_ARMCL_VERSION)\n #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL6X_VERSION)\n #undef JSON_HEDLEY_TI_CL6X_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)\n #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CL6X_VERSION)\n #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL7X_VERSION)\n #undef JSON_HEDLEY_TI_CL7X_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)\n #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CL7X_VERSION)\n #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)\n #undef JSON_HEDLEY_TI_CLPRU_VERSION\n#endif\n#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)\n #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))\n#endif\n\n#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)\n #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TI_CLPRU_VERSION)\n #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_CRAY_VERSION)\n #undef JSON_HEDLEY_CRAY_VERSION\n#endif\n#if defined(_CRAYC)\n #if defined(_RELEASE_PATCHLEVEL)\n #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)\n #else\n #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)\n #endif\n#endif\n\n#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)\n #undef JSON_HEDLEY_CRAY_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_CRAY_VERSION)\n #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_IAR_VERSION)\n #undef JSON_HEDLEY_IAR_VERSION\n#endif\n#if defined(__IAR_SYSTEMS_ICC__)\n #if __VER__ > 1000\n #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))\n #else\n #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0)\n #endif\n#endif\n\n#if defined(JSON_HEDLEY_IAR_VERSION_CHECK)\n #undef JSON_HEDLEY_IAR_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_IAR_VERSION)\n #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_TINYC_VERSION)\n #undef JSON_HEDLEY_TINYC_VERSION\n#endif\n#if defined(__TINYC__)\n #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)\n#endif\n\n#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)\n #undef JSON_HEDLEY_TINYC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_TINYC_VERSION)\n #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_DMC_VERSION)\n #undef JSON_HEDLEY_DMC_VERSION\n#endif\n#if defined(__DMC__)\n #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)\n#endif\n\n#if defined(JSON_HEDLEY_DMC_VERSION_CHECK)\n #undef JSON_HEDLEY_DMC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_DMC_VERSION)\n #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_COMPCERT_VERSION)\n #undef JSON_HEDLEY_COMPCERT_VERSION\n#endif\n#if defined(__COMPCERT_VERSION__)\n #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)\n#endif\n\n#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)\n #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_COMPCERT_VERSION)\n #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_PELLES_VERSION)\n #undef JSON_HEDLEY_PELLES_VERSION\n#endif\n#if defined(__POCC__)\n #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)\n#endif\n\n#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)\n #undef JSON_HEDLEY_PELLES_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_PELLES_VERSION)\n #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_MCST_LCC_VERSION)\n #undef JSON_HEDLEY_MCST_LCC_VERSION\n#endif\n#if defined(__LCC__) && defined(__LCC_MINOR__)\n #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__)\n#endif\n\n#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK)\n #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_MCST_LCC_VERSION)\n #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_VERSION)\n #undef JSON_HEDLEY_GCC_VERSION\n#endif\n#if \\\n defined(JSON_HEDLEY_GNUC_VERSION) && \\\n !defined(__clang__) && \\\n !defined(JSON_HEDLEY_INTEL_VERSION) && \\\n !defined(JSON_HEDLEY_PGI_VERSION) && \\\n !defined(JSON_HEDLEY_ARM_VERSION) && \\\n !defined(JSON_HEDLEY_CRAY_VERSION) && \\\n !defined(JSON_HEDLEY_TI_VERSION) && \\\n !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CL430_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \\\n !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \\\n !defined(__COMPCERT__) && \\\n !defined(JSON_HEDLEY_MCST_LCC_VERSION)\n #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION\n#endif\n\n#if defined(JSON_HEDLEY_GCC_VERSION_CHECK)\n #undef JSON_HEDLEY_GCC_VERSION_CHECK\n#endif\n#if defined(JSON_HEDLEY_GCC_VERSION)\n #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))\n#else\n #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_ATTRIBUTE)\n #undef JSON_HEDLEY_HAS_ATTRIBUTE\n#endif\n#if \\\n defined(__has_attribute) && \\\n ( \\\n (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \\\n )\n# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)\n#else\n# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)\n #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE\n#endif\n#if defined(__has_attribute)\n #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)\n#else\n #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)\n #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE\n#endif\n#if defined(__has_attribute)\n #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)\n#else\n #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)\n #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE\n#endif\n#if \\\n defined(__has_cpp_attribute) && \\\n defined(__cplusplus) && \\\n (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)\n#else\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)\n #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS\n#endif\n#if !defined(__cplusplus) || !defined(__has_cpp_attribute)\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)\n#elif \\\n !defined(JSON_HEDLEY_PGI_VERSION) && \\\n !defined(JSON_HEDLEY_IAR_VERSION) && \\\n (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \\\n (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)\n#else\n #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)\n #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE\n#endif\n#if defined(__has_cpp_attribute) && defined(__cplusplus)\n #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)\n#else\n #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)\n #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE\n#endif\n#if defined(__has_cpp_attribute) && defined(__cplusplus)\n #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)\n#else\n #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_BUILTIN)\n #undef JSON_HEDLEY_HAS_BUILTIN\n#endif\n#if defined(__has_builtin)\n #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)\n#else\n #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)\n #undef JSON_HEDLEY_GNUC_HAS_BUILTIN\n#endif\n#if defined(__has_builtin)\n #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)\n#else\n #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)\n #undef JSON_HEDLEY_GCC_HAS_BUILTIN\n#endif\n#if defined(__has_builtin)\n #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)\n#else\n #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_FEATURE)\n #undef JSON_HEDLEY_HAS_FEATURE\n#endif\n#if defined(__has_feature)\n #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)\n#else\n #define JSON_HEDLEY_HAS_FEATURE(feature) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)\n #undef JSON_HEDLEY_GNUC_HAS_FEATURE\n#endif\n#if defined(__has_feature)\n #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)\n#else\n #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_FEATURE)\n #undef JSON_HEDLEY_GCC_HAS_FEATURE\n#endif\n#if defined(__has_feature)\n #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)\n#else\n #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_EXTENSION)\n #undef JSON_HEDLEY_HAS_EXTENSION\n#endif\n#if defined(__has_extension)\n #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)\n#else\n #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)\n #undef JSON_HEDLEY_GNUC_HAS_EXTENSION\n#endif\n#if defined(__has_extension)\n #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)\n#else\n #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)\n #undef JSON_HEDLEY_GCC_HAS_EXTENSION\n#endif\n#if defined(__has_extension)\n #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)\n#else\n #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)\n #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE\n#endif\n#if defined(__has_declspec_attribute)\n #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)\n#else\n #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)\n #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE\n#endif\n#if defined(__has_declspec_attribute)\n #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)\n#else\n #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)\n #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE\n#endif\n#if defined(__has_declspec_attribute)\n #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)\n#else\n #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_HAS_WARNING)\n #undef JSON_HEDLEY_HAS_WARNING\n#endif\n#if defined(__has_warning)\n #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)\n#else\n #define JSON_HEDLEY_HAS_WARNING(warning) (0)\n#endif\n\n#if defined(JSON_HEDLEY_GNUC_HAS_WARNING)\n #undef JSON_HEDLEY_GNUC_HAS_WARNING\n#endif\n#if defined(__has_warning)\n #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)\n#else\n #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_GCC_HAS_WARNING)\n #undef JSON_HEDLEY_GCC_HAS_WARNING\n#endif\n#if defined(__has_warning)\n #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)\n#else\n #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if \\\n (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \\\n defined(__clang__) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \\\n JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \\\n (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))\n #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)\n #define JSON_HEDLEY_PRAGMA(value) __pragma(value)\n#else\n #define JSON_HEDLEY_PRAGMA(value)\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)\n #undef JSON_HEDLEY_DIAGNOSTIC_PUSH\n#endif\n#if defined(JSON_HEDLEY_DIAGNOSTIC_POP)\n #undef JSON_HEDLEY_DIAGNOSTIC_POP\n#endif\n#if defined(__clang__)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"clang diagnostic push\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"clang diagnostic pop\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"warning(push)\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"warning(pop)\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"GCC diagnostic push\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"GCC diagnostic pop\")\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))\n #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))\n#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"push\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"pop\")\n#elif \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"diag_push\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"diag_pop\")\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma(\"warning(push)\")\n #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma(\"warning(pop)\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_PUSH\n #define JSON_HEDLEY_DIAGNOSTIC_POP\n#endif\n\n/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for\n HEDLEY INTERNAL USE ONLY. API subject to change without notice. */\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_\n#endif\n#if defined(__cplusplus)\n# if JSON_HEDLEY_HAS_WARNING(\"-Wc++98-compat\")\n# if JSON_HEDLEY_HAS_WARNING(\"-Wc++17-extensions\")\n# if JSON_HEDLEY_HAS_WARNING(\"-Wc++1z-extensions\")\n# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++98-compat\\\"\") \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++17-extensions\\\"\") \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++1z-extensions\\\"\") \\\n xpr \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# else\n# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++98-compat\\\"\") \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++17-extensions\\\"\") \\\n xpr \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# endif\n# else\n# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wc++98-compat\\\"\") \\\n xpr \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# endif\n# endif\n#endif\n#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x\n#endif\n\n#if defined(JSON_HEDLEY_CONST_CAST)\n #undef JSON_HEDLEY_CONST_CAST\n#endif\n#if defined(__cplusplus)\n# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr))\n#elif \\\n JSON_HEDLEY_HAS_WARNING(\"-Wcast-qual\") || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \\\n ((T) (expr)); \\\n JSON_HEDLEY_DIAGNOSTIC_POP \\\n }))\n#else\n# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))\n#endif\n\n#if defined(JSON_HEDLEY_REINTERPRET_CAST)\n #undef JSON_HEDLEY_REINTERPRET_CAST\n#endif\n#if defined(__cplusplus)\n #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr))\n#else\n #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))\n#endif\n\n#if defined(JSON_HEDLEY_STATIC_CAST)\n #undef JSON_HEDLEY_STATIC_CAST\n#endif\n#if defined(__cplusplus)\n #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr))\n#else\n #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))\n#endif\n\n#if defined(JSON_HEDLEY_CPP_CAST)\n #undef JSON_HEDLEY_CPP_CAST\n#endif\n#if defined(__cplusplus)\n# if JSON_HEDLEY_HAS_WARNING(\"-Wold-style-cast\")\n# define JSON_HEDLEY_CPP_CAST(T, expr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wold-style-cast\\\"\") \\\n ((T) (expr)) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)\n# define JSON_HEDLEY_CPP_CAST(T, expr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"diag_suppress=Pe137\") \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# else\n# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))\n# endif\n#else\n# define JSON_HEDLEY_CPP_CAST(T, expr) (expr)\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wdeprecated-declarations\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"clang diagnostic ignored \\\"-Wdeprecated-declarations\\\"\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"warning(disable:1478 1786)\")\n#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786))\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress 1215,1216,1444,1445\")\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress 1215,1444\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"GCC diagnostic ignored \\\"-Wdeprecated-declarations\\\"\")\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))\n#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress 1215,1444\")\n#elif \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress 1291,1718\")\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)\")\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"error_messages(off,symdeprecated,symdeprecated2)\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"diag_suppress=Pe1444,Pe1215\")\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma(\"warn(disable:2241)\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunknown-pragmas\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"clang diagnostic ignored \\\"-Wunknown-pragmas\\\"\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"warning(disable:161)\")\n#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161))\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress 1675\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"GCC diagnostic ignored \\\"-Wunknown-pragmas\\\"\")\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))\n#elif \\\n JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress 163\")\n#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress 163\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress=Pe161\")\n#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma(\"diag_suppress 161\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunknown-attributes\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"clang diagnostic ignored \\\"-Wunknown-attributes\\\"\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"GCC diagnostic ignored \\\"-Wdeprecated-declarations\\\"\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"warning(disable:1292)\")\n#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292))\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress 1097,1098\")\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress 1097\")\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"error_messages(off,attrskipunsup)\")\n#elif \\\n JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress 1173\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress=Pe1097\")\n#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma(\"diag_suppress 1097\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wcast-qual\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma(\"clang diagnostic ignored \\\"-Wcast-qual\\\"\")\n#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma(\"warning(disable:2203 2331)\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma(\"GCC diagnostic ignored \\\"-Wcast-qual\\\"\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL\n#endif\n\n#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION)\n #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunused-function\")\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma(\"clang diagnostic ignored \\\"-Wunused-function\\\"\")\n#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma(\"GCC diagnostic ignored \\\"-Wunused-function\\\"\")\n#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505))\n#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma(\"diag_suppress 3142\")\n#else\n #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION\n#endif\n\n#if defined(JSON_HEDLEY_DEPRECATED)\n #undef JSON_HEDLEY_DEPRECATED\n#endif\n#if defined(JSON_HEDLEY_DEPRECATED_FOR)\n #undef JSON_HEDLEY_DEPRECATED_FOR\n#endif\n#if \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated(\"Since \" # since))\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated(\"Since \" #since \"; use \" #replacement))\n#elif \\\n (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__(\"Since \" #since)))\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__(\"Since \" #since \"; use \" #replacement)))\n#elif defined(__cplusplus) && (__cplusplus >= 201402L)\n #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated(\"Since \" #since)]])\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated(\"Since \" #since \"; use \" #replacement)]])\n#elif \\\n JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)\n #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \\\n JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_DEPRECATED(since) _Pragma(\"deprecated\")\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma(\"deprecated\")\n#else\n #define JSON_HEDLEY_DEPRECATED(since)\n #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)\n#endif\n\n#if defined(JSON_HEDLEY_UNAVAILABLE)\n #undef JSON_HEDLEY_UNAVAILABLE\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__(\"Not available until \" #available_since)))\n#else\n #define JSON_HEDLEY_UNAVAILABLE(available_since)\n#endif\n\n#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)\n #undef JSON_HEDLEY_WARN_UNUSED_RESULT\n#endif\n#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)\n #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))\n#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)\n #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])\n#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)\n #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])\n#elif defined(_Check_return_) /* SAL */\n #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_\n#else\n #define JSON_HEDLEY_WARN_UNUSED_RESULT\n #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)\n#endif\n\n#if defined(JSON_HEDLEY_SENTINEL)\n #undef JSON_HEDLEY_SENTINEL\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))\n#else\n #define JSON_HEDLEY_SENTINEL(position)\n#endif\n\n#if defined(JSON_HEDLEY_NO_RETURN)\n #undef JSON_HEDLEY_NO_RETURN\n#endif\n#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_NO_RETURN __noreturn\n#elif \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))\n#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L\n #define JSON_HEDLEY_NO_RETURN _Noreturn\n#elif defined(__cplusplus) && (__cplusplus >= 201103L)\n #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])\n#elif \\\n JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)\n #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)\n #define JSON_HEDLEY_NO_RETURN _Pragma(\"does_not_return\")\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)\n#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)\n #define JSON_HEDLEY_NO_RETURN _Pragma(\"FUNC_NEVER_RETURNS;\")\n#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)\n #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)\n #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)\n#else\n #define JSON_HEDLEY_NO_RETURN\n#endif\n\n#if defined(JSON_HEDLEY_NO_ESCAPE)\n #undef JSON_HEDLEY_NO_ESCAPE\n#endif\n#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)\n #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))\n#else\n #define JSON_HEDLEY_NO_ESCAPE\n#endif\n\n#if defined(JSON_HEDLEY_UNREACHABLE)\n #undef JSON_HEDLEY_UNREACHABLE\n#endif\n#if defined(JSON_HEDLEY_UNREACHABLE_RETURN)\n #undef JSON_HEDLEY_UNREACHABLE_RETURN\n#endif\n#if defined(JSON_HEDLEY_ASSUME)\n #undef JSON_HEDLEY_ASSUME\n#endif\n#if \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_ASSUME(expr) __assume(expr)\n#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)\n #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)\n#elif \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)\n #if defined(__cplusplus)\n #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)\n #else\n #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)\n #endif\n#endif\n#if \\\n (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()\n#elif defined(JSON_HEDLEY_ASSUME)\n #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)\n#endif\n#if !defined(JSON_HEDLEY_ASSUME)\n #if defined(JSON_HEDLEY_UNREACHABLE)\n #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))\n #else\n #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)\n #endif\n#endif\n#if defined(JSON_HEDLEY_UNREACHABLE)\n #if \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)\n #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))\n #else\n #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()\n #endif\n#else\n #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)\n#endif\n#if !defined(JSON_HEDLEY_UNREACHABLE)\n #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)\n#endif\n\nJSON_HEDLEY_DIAGNOSTIC_PUSH\n#if JSON_HEDLEY_HAS_WARNING(\"-Wpedantic\")\n #pragma clang diagnostic ignored \"-Wpedantic\"\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wc++98-compat-pedantic\") && defined(__cplusplus)\n #pragma clang diagnostic ignored \"-Wc++98-compat-pedantic\"\n#endif\n#if JSON_HEDLEY_GCC_HAS_WARNING(\"-Wvariadic-macros\",4,0,0)\n #if defined(__clang__)\n #pragma clang diagnostic ignored \"-Wvariadic-macros\"\n #elif defined(JSON_HEDLEY_GCC_VERSION)\n #pragma GCC diagnostic ignored \"-Wvariadic-macros\"\n #endif\n#endif\n#if defined(JSON_HEDLEY_NON_NULL)\n #undef JSON_HEDLEY_NON_NULL\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)\n #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))\n#else\n #define JSON_HEDLEY_NON_NULL(...)\n#endif\nJSON_HEDLEY_DIAGNOSTIC_POP\n\n#if defined(JSON_HEDLEY_PRINTF_FORMAT)\n #undef JSON_HEDLEY_PRINTF_FORMAT\n#endif\n#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))\n#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))\n#elif \\\n JSON_HEDLEY_HAS_ATTRIBUTE(format) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))\n#else\n #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)\n#endif\n\n#if defined(JSON_HEDLEY_CONSTEXPR)\n #undef JSON_HEDLEY_CONSTEXPR\n#endif\n#if defined(__cplusplus)\n #if __cplusplus >= 201103L\n #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)\n #endif\n#endif\n#if !defined(JSON_HEDLEY_CONSTEXPR)\n #define JSON_HEDLEY_CONSTEXPR\n#endif\n\n#if defined(JSON_HEDLEY_PREDICT)\n #undef JSON_HEDLEY_PREDICT\n#endif\n#if defined(JSON_HEDLEY_LIKELY)\n #undef JSON_HEDLEY_LIKELY\n#endif\n#if defined(JSON_HEDLEY_UNLIKELY)\n #undef JSON_HEDLEY_UNLIKELY\n#endif\n#if defined(JSON_HEDLEY_UNPREDICTABLE)\n #undef JSON_HEDLEY_UNPREDICTABLE\n#endif\n#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)\n #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))\n#endif\n#if \\\n (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability))\n# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability))\n# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability))\n# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 )\n# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 )\n#elif \\\n (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n# define JSON_HEDLEY_PREDICT(expr, expected, probability) \\\n (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))\n# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \\\n (__extension__ ({ \\\n double hedley_probability_ = (probability); \\\n ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \\\n }))\n# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \\\n (__extension__ ({ \\\n double hedley_probability_ = (probability); \\\n ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \\\n }))\n# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)\n# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)\n#else\n# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))\n# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))\n# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))\n# define JSON_HEDLEY_LIKELY(expr) (!!(expr))\n# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))\n#endif\n#if !defined(JSON_HEDLEY_UNPREDICTABLE)\n #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)\n#endif\n\n#if defined(JSON_HEDLEY_MALLOC)\n #undef JSON_HEDLEY_MALLOC\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)\n #define JSON_HEDLEY_MALLOC _Pragma(\"returns_new_memory\")\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_MALLOC __declspec(restrict)\n#else\n #define JSON_HEDLEY_MALLOC\n#endif\n\n#if defined(JSON_HEDLEY_PURE)\n #undef JSON_HEDLEY_PURE\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n# define JSON_HEDLEY_PURE __attribute__((__pure__))\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)\n# define JSON_HEDLEY_PURE _Pragma(\"does_not_write_global_data\")\n#elif defined(__cplusplus) && \\\n ( \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \\\n )\n# define JSON_HEDLEY_PURE _Pragma(\"FUNC_IS_PURE;\")\n#else\n# define JSON_HEDLEY_PURE\n#endif\n\n#if defined(JSON_HEDLEY_CONST)\n #undef JSON_HEDLEY_CONST\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(const) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_CONST __attribute__((__const__))\n#elif \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)\n #define JSON_HEDLEY_CONST _Pragma(\"no_side_effect\")\n#else\n #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE\n#endif\n\n#if defined(JSON_HEDLEY_RESTRICT)\n #undef JSON_HEDLEY_RESTRICT\n#endif\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)\n #define JSON_HEDLEY_RESTRICT restrict\n#elif \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \\\n defined(__clang__) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_RESTRICT __restrict\n#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)\n #define JSON_HEDLEY_RESTRICT _Restrict\n#else\n #define JSON_HEDLEY_RESTRICT\n#endif\n\n#if defined(JSON_HEDLEY_INLINE)\n #undef JSON_HEDLEY_INLINE\n#endif\n#if \\\n (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \\\n (defined(__cplusplus) && (__cplusplus >= 199711L))\n #define JSON_HEDLEY_INLINE inline\n#elif \\\n defined(JSON_HEDLEY_GCC_VERSION) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)\n #define JSON_HEDLEY_INLINE __inline__\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_INLINE __inline\n#else\n #define JSON_HEDLEY_INLINE\n#endif\n\n#if defined(JSON_HEDLEY_ALWAYS_INLINE)\n #undef JSON_HEDLEY_ALWAYS_INLINE\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)\n# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n# define JSON_HEDLEY_ALWAYS_INLINE __forceinline\n#elif defined(__cplusplus) && \\\n ( \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \\\n )\n# define JSON_HEDLEY_ALWAYS_INLINE _Pragma(\"FUNC_ALWAYS_INLINE;\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n# define JSON_HEDLEY_ALWAYS_INLINE _Pragma(\"inline=forced\")\n#else\n# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE\n#endif\n\n#if defined(JSON_HEDLEY_NEVER_INLINE)\n #undef JSON_HEDLEY_NEVER_INLINE\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \\\n JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \\\n (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \\\n (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \\\n (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \\\n JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \\\n JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \\\n JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0)\n #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)\n#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)\n #define JSON_HEDLEY_NEVER_INLINE _Pragma(\"noinline\")\n#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)\n #define JSON_HEDLEY_NEVER_INLINE _Pragma(\"FUNC_CANNOT_INLINE;\")\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n #define JSON_HEDLEY_NEVER_INLINE _Pragma(\"inline=never\")\n#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)\n #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)\n #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)\n#else\n #define JSON_HEDLEY_NEVER_INLINE\n#endif\n\n#if defined(JSON_HEDLEY_PRIVATE)\n #undef JSON_HEDLEY_PRIVATE\n#endif\n#if defined(JSON_HEDLEY_PUBLIC)\n #undef JSON_HEDLEY_PUBLIC\n#endif\n#if defined(JSON_HEDLEY_IMPORT)\n #undef JSON_HEDLEY_IMPORT\n#endif\n#if defined(_WIN32) || defined(__CYGWIN__)\n# define JSON_HEDLEY_PRIVATE\n# define JSON_HEDLEY_PUBLIC __declspec(dllexport)\n# define JSON_HEDLEY_IMPORT __declspec(dllimport)\n#else\n# if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \\\n JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \\\n ( \\\n defined(__TI_EABI__) && \\\n ( \\\n (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \\\n ) \\\n ) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__(\"hidden\")))\n# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__(\"default\")))\n# else\n# define JSON_HEDLEY_PRIVATE\n# define JSON_HEDLEY_PUBLIC\n# endif\n# define JSON_HEDLEY_IMPORT extern\n#endif\n\n#if defined(JSON_HEDLEY_NO_THROW)\n #undef JSON_HEDLEY_NO_THROW\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)\n #define JSON_HEDLEY_NO_THROW __declspec(nothrow)\n#else\n #define JSON_HEDLEY_NO_THROW\n#endif\n\n#if defined(JSON_HEDLEY_FALL_THROUGH)\n #undef JSON_HEDLEY_FALL_THROUGH\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))\n#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)\n #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])\n#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)\n #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])\n#elif defined(__fallthrough) /* SAL */\n #define JSON_HEDLEY_FALL_THROUGH __fallthrough\n#else\n #define JSON_HEDLEY_FALL_THROUGH\n#endif\n\n#if defined(JSON_HEDLEY_RETURNS_NON_NULL)\n #undef JSON_HEDLEY_RETURNS_NON_NULL\n#endif\n#if \\\n JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))\n#elif defined(_Ret_notnull_) /* SAL */\n #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_\n#else\n #define JSON_HEDLEY_RETURNS_NON_NULL\n#endif\n\n#if defined(JSON_HEDLEY_ARRAY_PARAM)\n #undef JSON_HEDLEY_ARRAY_PARAM\n#endif\n#if \\\n defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \\\n !defined(__STDC_NO_VLA__) && \\\n !defined(__cplusplus) && \\\n !defined(JSON_HEDLEY_PGI_VERSION) && \\\n !defined(JSON_HEDLEY_TINYC_VERSION)\n #define JSON_HEDLEY_ARRAY_PARAM(name) (name)\n#else\n #define JSON_HEDLEY_ARRAY_PARAM(name)\n#endif\n\n#if defined(JSON_HEDLEY_IS_CONSTANT)\n #undef JSON_HEDLEY_IS_CONSTANT\n#endif\n#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)\n #undef JSON_HEDLEY_REQUIRE_CONSTEXPR\n#endif\n/* JSON_HEDLEY_IS_CONSTEXPR_ is for\n HEDLEY INTERNAL USE ONLY. API subject to change without notice. */\n#if defined(JSON_HEDLEY_IS_CONSTEXPR_)\n #undef JSON_HEDLEY_IS_CONSTEXPR_\n#endif\n#if \\\n JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \\\n JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \\\n (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10)\n #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)\n#endif\n#if !defined(__cplusplus)\n# if \\\n JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \\\n JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \\\n JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)\n#if defined(__INTPTR_TYPE__)\n #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)\n#else\n #include \n #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)\n#endif\n# elif \\\n ( \\\n defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \\\n !defined(JSON_HEDLEY_SUNPRO_VERSION) && \\\n !defined(JSON_HEDLEY_PGI_VERSION) && \\\n !defined(JSON_HEDLEY_IAR_VERSION)) || \\\n (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \\\n JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \\\n JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)\n#if defined(__INTPTR_TYPE__)\n #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)\n#else\n #include \n #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)\n#endif\n# elif \\\n defined(JSON_HEDLEY_GCC_VERSION) || \\\n defined(JSON_HEDLEY_INTEL_VERSION) || \\\n defined(JSON_HEDLEY_TINYC_VERSION) || \\\n defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \\\n JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \\\n defined(JSON_HEDLEY_TI_CL2000_VERSION) || \\\n defined(JSON_HEDLEY_TI_CL6X_VERSION) || \\\n defined(JSON_HEDLEY_TI_CL7X_VERSION) || \\\n defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \\\n defined(__clang__)\n# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \\\n sizeof(void) != \\\n sizeof(*( \\\n 1 ? \\\n ((void*) ((expr) * 0L) ) : \\\n((struct { char v[sizeof(void) * 2]; } *) 1) \\\n ) \\\n ) \\\n )\n# endif\n#endif\n#if defined(JSON_HEDLEY_IS_CONSTEXPR_)\n #if !defined(JSON_HEDLEY_IS_CONSTANT)\n #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)\n #endif\n #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))\n#else\n #if !defined(JSON_HEDLEY_IS_CONSTANT)\n #define JSON_HEDLEY_IS_CONSTANT(expr) (0)\n #endif\n #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)\n#endif\n\n#if defined(JSON_HEDLEY_BEGIN_C_DECLS)\n #undef JSON_HEDLEY_BEGIN_C_DECLS\n#endif\n#if defined(JSON_HEDLEY_END_C_DECLS)\n #undef JSON_HEDLEY_END_C_DECLS\n#endif\n#if defined(JSON_HEDLEY_C_DECL)\n #undef JSON_HEDLEY_C_DECL\n#endif\n#if defined(__cplusplus)\n #define JSON_HEDLEY_BEGIN_C_DECLS extern \"C\" {\n #define JSON_HEDLEY_END_C_DECLS }\n #define JSON_HEDLEY_C_DECL extern \"C\"\n#else\n #define JSON_HEDLEY_BEGIN_C_DECLS\n #define JSON_HEDLEY_END_C_DECLS\n #define JSON_HEDLEY_C_DECL\n#endif\n\n#if defined(JSON_HEDLEY_STATIC_ASSERT)\n #undef JSON_HEDLEY_STATIC_ASSERT\n#endif\n#if \\\n !defined(__cplusplus) && ( \\\n (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \\\n (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \\\n JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \\\n defined(_Static_assert) \\\n )\n# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)\n#elif \\\n (defined(__cplusplus) && (__cplusplus >= 201103L)) || \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))\n#else\n# define JSON_HEDLEY_STATIC_ASSERT(expr, message)\n#endif\n\n#if defined(JSON_HEDLEY_NULL)\n #undef JSON_HEDLEY_NULL\n#endif\n#if defined(__cplusplus)\n #if __cplusplus >= 201103L\n #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)\n #elif defined(NULL)\n #define JSON_HEDLEY_NULL NULL\n #else\n #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)\n #endif\n#elif defined(NULL)\n #define JSON_HEDLEY_NULL NULL\n#else\n #define JSON_HEDLEY_NULL ((void*) 0)\n#endif\n\n#if defined(JSON_HEDLEY_MESSAGE)\n #undef JSON_HEDLEY_MESSAGE\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunknown-pragmas\")\n# define JSON_HEDLEY_MESSAGE(msg) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \\\n JSON_HEDLEY_PRAGMA(message msg) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n#elif \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)\n#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)\n# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)\n#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)\n# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))\n#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)\n# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))\n#else\n# define JSON_HEDLEY_MESSAGE(msg)\n#endif\n\n#if defined(JSON_HEDLEY_WARNING)\n #undef JSON_HEDLEY_WARNING\n#endif\n#if JSON_HEDLEY_HAS_WARNING(\"-Wunknown-pragmas\")\n# define JSON_HEDLEY_WARNING(msg) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \\\n JSON_HEDLEY_PRAGMA(clang warning msg) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n#elif \\\n JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \\\n JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \\\n JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)\n# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)\n#elif \\\n JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))\n#else\n# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)\n#endif\n\n#if defined(JSON_HEDLEY_REQUIRE)\n #undef JSON_HEDLEY_REQUIRE\n#endif\n#if defined(JSON_HEDLEY_REQUIRE_MSG)\n #undef JSON_HEDLEY_REQUIRE_MSG\n#endif\n#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)\n# if JSON_HEDLEY_HAS_WARNING(\"-Wgcc-compat\")\n# define JSON_HEDLEY_REQUIRE(expr) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wgcc-compat\\\"\") \\\n __attribute__((diagnose_if(!(expr), #expr, \"error\"))) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"clang diagnostic ignored \\\"-Wgcc-compat\\\"\") \\\n __attribute__((diagnose_if(!(expr), msg, \"error\"))) \\\n JSON_HEDLEY_DIAGNOSTIC_POP\n# else\n# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, \"error\")))\n# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, \"error\")))\n# endif\n#else\n# define JSON_HEDLEY_REQUIRE(expr)\n# define JSON_HEDLEY_REQUIRE_MSG(expr,msg)\n#endif\n\n#if defined(JSON_HEDLEY_FLAGS)\n #undef JSON_HEDLEY_FLAGS\n#endif\n#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING(\"-Wbitfield-enum-conversion\"))\n #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))\n#else\n #define JSON_HEDLEY_FLAGS\n#endif\n\n#if defined(JSON_HEDLEY_FLAGS_CAST)\n #undef JSON_HEDLEY_FLAGS_CAST\n#endif\n#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)\n# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \\\n JSON_HEDLEY_DIAGNOSTIC_PUSH \\\n _Pragma(\"warning(disable:188)\") \\\n ((T) (expr)); \\\n JSON_HEDLEY_DIAGNOSTIC_POP \\\n }))\n#else\n# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)\n#endif\n\n#if defined(JSON_HEDLEY_EMPTY_BASES)\n #undef JSON_HEDLEY_EMPTY_BASES\n#endif\n#if \\\n (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \\\n JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0)\n #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)\n#else\n #define JSON_HEDLEY_EMPTY_BASES\n#endif\n\n/* Remaining macros are deprecated. */\n\n#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)\n #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK\n#endif\n#if defined(__clang__)\n #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)\n#else\n #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)\n#endif\n\n#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)\n #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE\n#endif\n#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)\n #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE\n#endif\n#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)\n #undef JSON_HEDLEY_CLANG_HAS_BUILTIN\n#endif\n#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)\n #undef JSON_HEDLEY_CLANG_HAS_FEATURE\n#endif\n#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)\n #undef JSON_HEDLEY_CLANG_HAS_EXTENSION\n#endif\n#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)\n #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE\n#endif\n#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)\n\n#if defined(JSON_HEDLEY_CLANG_HAS_WARNING)\n #undef JSON_HEDLEY_CLANG_HAS_WARNING\n#endif\n#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)\n\n#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */\n\n\n// This file contains all internal macro definitions (except those affecting ABI)\n// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them\n\n// #include \n\n\n// exclude unsupported compilers\n#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)\n #if defined(__clang__)\n #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400\n #error \"unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers\"\n #endif\n #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))\n #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800\n #error \"unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers\"\n #endif\n #endif\n#endif\n\n// C++ language standard detection\n// if the user manually specified the used c++ version this is skipped\n#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11)\n #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)\n #define JSON_HAS_CPP_20\n #define JSON_HAS_CPP_17\n #define JSON_HAS_CPP_14\n #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464\n #define JSON_HAS_CPP_17\n #define JSON_HAS_CPP_14\n #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)\n #define JSON_HAS_CPP_14\n #endif\n // the cpp 11 flag is always specified because it is the minimal required version\n #define JSON_HAS_CPP_11\n#endif\n\n#ifdef __has_include\n #if __has_include()\n #include \n #endif\n#endif\n\n#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM)\n #ifdef JSON_HAS_CPP_17\n #if defined(__cpp_lib_filesystem)\n #define JSON_HAS_FILESYSTEM 1\n #elif defined(__cpp_lib_experimental_filesystem)\n #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1\n #elif !defined(__has_include)\n #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1\n #elif __has_include()\n #define JSON_HAS_FILESYSTEM 1\n #elif __has_include()\n #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1\n #endif\n\n // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/\n #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support\n #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support\n #if defined(__clang_major__) && __clang_major__ < 7\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support\n #if defined(_MSC_VER) && _MSC_VER < 1914\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before iOS 13\n #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n\n // no filesystem support before macOS Catalina\n #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500\n #undef JSON_HAS_FILESYSTEM\n #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #endif\n #endif\n#endif\n\n#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM\n #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0\n#endif\n\n#ifndef JSON_HAS_FILESYSTEM\n #define JSON_HAS_FILESYSTEM 0\n#endif\n\n#ifndef JSON_HAS_THREE_WAY_COMPARISON\n #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \\\n && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L\n #define JSON_HAS_THREE_WAY_COMPARISON 1\n #else\n #define JSON_HAS_THREE_WAY_COMPARISON 0\n #endif\n#endif\n\n#ifndef JSON_HAS_RANGES\n // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error\n #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427\n #define JSON_HAS_RANGES 0\n #elif defined(__cpp_lib_ranges)\n #define JSON_HAS_RANGES 1\n #else\n #define JSON_HAS_RANGES 0\n #endif\n#endif\n\n#ifdef JSON_HAS_CPP_17\n #define JSON_INLINE_VARIABLE inline\n#else\n #define JSON_INLINE_VARIABLE\n#endif\n\n#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address)\n #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]]\n#else\n #define JSON_NO_UNIQUE_ADDRESS\n#endif\n\n// disable documentation warnings on clang\n#if defined(__clang__)\n #pragma clang diagnostic push\n #pragma clang diagnostic ignored \"-Wdocumentation\"\n #pragma clang diagnostic ignored \"-Wdocumentation-unknown-command\"\n#endif\n\n// allow disabling exceptions\n#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)\n #define JSON_THROW(exception) throw exception\n #define JSON_TRY try\n #define JSON_CATCH(exception) catch(exception)\n #define JSON_INTERNAL_CATCH(exception) catch(exception)\n#else\n #include \n #define JSON_THROW(exception) std::abort()\n #define JSON_TRY if(true)\n #define JSON_CATCH(exception) if(false)\n #define JSON_INTERNAL_CATCH(exception) if(false)\n#endif\n\n// override exception macros\n#if defined(JSON_THROW_USER)\n #undef JSON_THROW\n #define JSON_THROW JSON_THROW_USER\n#endif\n#if defined(JSON_TRY_USER)\n #undef JSON_TRY\n #define JSON_TRY JSON_TRY_USER\n#endif\n#if defined(JSON_CATCH_USER)\n #undef JSON_CATCH\n #define JSON_CATCH JSON_CATCH_USER\n #undef JSON_INTERNAL_CATCH\n #define JSON_INTERNAL_CATCH JSON_CATCH_USER\n#endif\n#if defined(JSON_INTERNAL_CATCH_USER)\n #undef JSON_INTERNAL_CATCH\n #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER\n#endif\n\n// allow overriding assert\n#if !defined(JSON_ASSERT)\n #include // assert\n #define JSON_ASSERT(x) assert(x)\n#endif\n\n// allow to access some private functions (needed by the test suite)\n#if defined(JSON_TESTS_PRIVATE)\n #define JSON_PRIVATE_UNLESS_TESTED public\n#else\n #define JSON_PRIVATE_UNLESS_TESTED private\n#endif\n\n/*!\n@brief macro to briefly define a mapping between an enum and JSON\n@def NLOHMANN_JSON_SERIALIZE_ENUM\n@since version 3.4.0\n*/\n#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \\\n template \\\n inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \\\n { \\\n static_assert(std::is_enum::value, #ENUM_TYPE \" must be an enum!\"); \\\n static const std::pair m[] = __VA_ARGS__; \\\n auto it = std::find_if(std::begin(m), std::end(m), \\\n [e](const std::pair& ej_pair) -> bool \\\n { \\\n return ej_pair.first == e; \\\n }); \\\n j = ((it != std::end(m)) ? it : std::begin(m))->second; \\\n } \\\n template \\\n inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \\\n { \\\n static_assert(std::is_enum::value, #ENUM_TYPE \" must be an enum!\"); \\\n static const std::pair m[] = __VA_ARGS__; \\\n auto it = std::find_if(std::begin(m), std::end(m), \\\n [&j](const std::pair& ej_pair) -> bool \\\n { \\\n return ej_pair.second == j; \\\n }); \\\n e = ((it != std::end(m)) ? it : std::begin(m))->first; \\\n }\n\n// Ugly macros to avoid uglier copy-paste when specializing basic_json. They\n// may be removed in the future once the class is split.\n\n#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \\\n template class ObjectType, \\\n template class ArrayType, \\\n class StringType, class BooleanType, class NumberIntegerType, \\\n class NumberUnsignedType, class NumberFloatType, \\\n template class AllocatorType, \\\n template class JSONSerializer, \\\n class BinaryType>\n\n#define NLOHMANN_BASIC_JSON_TPL \\\n basic_json\n\n// Macros to simplify conversion from/to types\n\n#define NLOHMANN_JSON_EXPAND( x ) x\n#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME\n#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \\\n NLOHMANN_JSON_PASTE64, \\\n NLOHMANN_JSON_PASTE63, \\\n NLOHMANN_JSON_PASTE62, \\\n NLOHMANN_JSON_PASTE61, \\\n NLOHMANN_JSON_PASTE60, \\\n NLOHMANN_JSON_PASTE59, \\\n NLOHMANN_JSON_PASTE58, \\\n NLOHMANN_JSON_PASTE57, \\\n NLOHMANN_JSON_PASTE56, \\\n NLOHMANN_JSON_PASTE55, \\\n NLOHMANN_JSON_PASTE54, \\\n NLOHMANN_JSON_PASTE53, \\\n NLOHMANN_JSON_PASTE52, \\\n NLOHMANN_JSON_PASTE51, \\\n NLOHMANN_JSON_PASTE50, \\\n NLOHMANN_JSON_PASTE49, \\\n NLOHMANN_JSON_PASTE48, \\\n NLOHMANN_JSON_PASTE47, \\\n NLOHMANN_JSON_PASTE46, \\\n NLOHMANN_JSON_PASTE45, \\\n NLOHMANN_JSON_PASTE44, \\\n NLOHMANN_JSON_PASTE43, \\\n NLOHMANN_JSON_PASTE42, \\\n NLOHMANN_JSON_PASTE41, \\\n NLOHMANN_JSON_PASTE40, \\\n NLOHMANN_JSON_PASTE39, \\\n NLOHMANN_JSON_PASTE38, \\\n NLOHMANN_JSON_PASTE37, \\\n NLOHMANN_JSON_PASTE36, \\\n NLOHMANN_JSON_PASTE35, \\\n NLOHMANN_JSON_PASTE34, \\\n NLOHMANN_JSON_PASTE33, \\\n NLOHMANN_JSON_PASTE32, \\\n NLOHMANN_JSON_PASTE31, \\\n NLOHMANN_JSON_PASTE30, \\\n NLOHMANN_JSON_PASTE29, \\\n NLOHMANN_JSON_PASTE28, \\\n NLOHMANN_JSON_PASTE27, \\\n NLOHMANN_JSON_PASTE26, \\\n NLOHMANN_JSON_PASTE25, \\\n NLOHMANN_JSON_PASTE24, \\\n NLOHMANN_JSON_PASTE23, \\\n NLOHMANN_JSON_PASTE22, \\\n NLOHMANN_JSON_PASTE21, \\\n NLOHMANN_JSON_PASTE20, \\\n NLOHMANN_JSON_PASTE19, \\\n NLOHMANN_JSON_PASTE18, \\\n NLOHMANN_JSON_PASTE17, \\\n NLOHMANN_JSON_PASTE16, \\\n NLOHMANN_JSON_PASTE15, \\\n NLOHMANN_JSON_PASTE14, \\\n NLOHMANN_JSON_PASTE13, \\\n NLOHMANN_JSON_PASTE12, \\\n NLOHMANN_JSON_PASTE11, \\\n NLOHMANN_JSON_PASTE10, \\\n NLOHMANN_JSON_PASTE9, \\\n NLOHMANN_JSON_PASTE8, \\\n NLOHMANN_JSON_PASTE7, \\\n NLOHMANN_JSON_PASTE6, \\\n NLOHMANN_JSON_PASTE5, \\\n NLOHMANN_JSON_PASTE4, \\\n NLOHMANN_JSON_PASTE3, \\\n NLOHMANN_JSON_PASTE2, \\\n NLOHMANN_JSON_PASTE1)(__VA_ARGS__))\n#define NLOHMANN_JSON_PASTE2(func, v1) func(v1)\n#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)\n#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)\n#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)\n#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)\n#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)\n#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)\n#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)\n#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)\n#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)\n#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)\n#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)\n#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)\n#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)\n#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)\n#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)\n#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)\n#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)\n#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)\n#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)\n#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)\n#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)\n#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)\n#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)\n#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)\n#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)\n#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)\n#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)\n#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)\n#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)\n#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)\n#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)\n#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)\n#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)\n#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)\n#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)\n#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)\n#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)\n#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)\n#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)\n#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)\n#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)\n#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)\n#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)\n#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)\n#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)\n#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)\n#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)\n#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)\n#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)\n#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)\n#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)\n#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)\n#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)\n#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)\n#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)\n#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)\n#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)\n#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)\n#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)\n#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)\n#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)\n#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)\n\n#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;\n#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);\n#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1);\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_TYPE_INTRUSIVE\n@since version 3.9.0\n*/\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \\\n friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }\n\n#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \\\n friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { Type nlohmann_json_default_obj; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }\n\n/*!\n@brief macro\n@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE\n@since version 3.9.0\n*/\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \\\n inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }\n\n#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \\\n inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \\\n inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { Type nlohmann_json_default_obj; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) }\n\n\n// inspired from https://stackoverflow.com/a/26745591\n// allows to call any std function as if (e.g. with begin):\n// using std::begin; begin(x);\n//\n// it allows using the detected idiom to retrieve the return type\n// of such an expression\n#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \\\n namespace detail { \\\n using std::std_name; \\\n \\\n template \\\n using result_of_##std_name = decltype(std_name(std::declval()...)); \\\n } \\\n \\\n namespace detail2 { \\\n struct std_name##_tag \\\n { \\\n }; \\\n \\\n template \\\n std_name##_tag std_name(T&&...); \\\n \\\n template \\\n using result_of_##std_name = decltype(std_name(std::declval()...)); \\\n \\\n template \\\n struct would_call_std_##std_name \\\n { \\\n static constexpr auto const value = ::nlohmann::detail:: \\\n is_detected_exact::value; \\\n }; \\\n } /* namespace detail2 */ \\\n \\\n template \\\n struct would_call_std_##std_name : detail2::would_call_std_##std_name \\\n { \\\n }\n\n#ifndef JSON_USE_IMPLICIT_CONVERSIONS\n #define JSON_USE_IMPLICIT_CONVERSIONS 1\n#endif\n\n#if JSON_USE_IMPLICIT_CONVERSIONS\n #define JSON_EXPLICIT\n#else\n #define JSON_EXPLICIT explicit\n#endif\n\n#ifndef JSON_DISABLE_ENUM_SERIALIZATION\n #define JSON_DISABLE_ENUM_SERIALIZATION 0\n#endif\n\n#ifndef JSON_USE_GLOBAL_UDLS\n #define JSON_USE_GLOBAL_UDLS 1\n#endif\n\n#if JSON_HAS_THREE_WAY_COMPARISON\n #include // partial_ordering\n#endif\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\n///////////////////////////\n// JSON type enumeration //\n///////////////////////////\n\n/*!\n@brief the JSON type enumeration\n\nThis enumeration collects the different JSON types. It is internally used to\ndistinguish the stored values, and the functions @ref basic_json::is_null(),\n@ref basic_json::is_object(), @ref basic_json::is_array(),\n@ref basic_json::is_string(), @ref basic_json::is_boolean(),\n@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),\n@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),\n@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and\n@ref basic_json::is_structured() rely on it.\n\n@note There are three enumeration entries (number_integer, number_unsigned, and\nnumber_float), because the library distinguishes these three types for numbers:\n@ref basic_json::number_unsigned_t is used for unsigned integers,\n@ref basic_json::number_integer_t is used for signed integers, and\n@ref basic_json::number_float_t is used for floating-point numbers or to\napproximate integers which do not fit in the limits of their respective type.\n\n@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON\nvalue with the default value for a given type\n\n@since version 1.0.0\n*/\nenum class value_t : std::uint8_t\n{\n null, ///< null value\n object, ///< object (unordered set of name/value pairs)\n array, ///< array (ordered collection of values)\n string, ///< string value\n boolean, ///< boolean value\n number_integer, ///< number value (signed integer)\n number_unsigned, ///< number value (unsigned integer)\n number_float, ///< number value (floating-point)\n binary, ///< binary array (ordered collection of bytes)\n discarded ///< discarded by the parser callback function\n};\n\n/*!\n@brief comparison operator for JSON types\n\nReturns an ordering that is similar to Python:\n- order: null < boolean < number < object < array < string < binary\n- furthermore, each type is not smaller than itself\n- discarded values are not comparable\n- binary is represented as a b\"\" string in python and directly comparable to a\n string; however, making a binary array directly comparable with a string would\n be surprising behavior in a JSON file.\n\n@since version 1.0.0\n*/\n#if JSON_HAS_THREE_WAY_COMPARISON\n inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD*\n#else\n inline bool operator<(const value_t lhs, const value_t rhs) noexcept\n#endif\n{\n static constexpr std::array order = {{\n 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,\n 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,\n 6 /* binary */\n }\n };\n\n const auto l_index = static_cast(lhs);\n const auto r_index = static_cast(rhs);\n#if JSON_HAS_THREE_WAY_COMPARISON\n if (l_index < order.size() && r_index < order.size())\n {\n return order[l_index] <=> order[r_index]; // *NOPAD*\n }\n return std::partial_ordering::unordered;\n#else\n return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];\n#endif\n}\n\n// GCC selects the built-in operator< over an operator rewritten from\n// a user-defined spaceship operator\n// Clang, MSVC, and ICC select the rewritten candidate\n// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200)\n#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__)\ninline bool operator<(const value_t lhs, const value_t rhs) noexcept\n{\n return std::is_lt(lhs <=> rhs); // *NOPAD*\n}\n#endif\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\n/*!\n@brief replace all occurrences of a substring by another string\n\n@param[in,out] s the string to manipulate; changed so that all\n occurrences of @a f are replaced with @a t\n@param[in] f the substring to replace with @a t\n@param[in] t the string to replace @a f\n\n@pre The search string @a f must not be empty. **This precondition is\nenforced with an assertion.**\n\n@since version 2.0.0\n*/\ntemplate\ninline void replace_substring(StringType& s, const StringType& f,\n const StringType& t)\n{\n JSON_ASSERT(!f.empty());\n for (auto pos = s.find(f); // find first occurrence of f\n pos != StringType::npos; // make sure f was found\n s.replace(pos, f.size(), t), // replace with t, and\n pos = s.find(f, pos + t.size())) // find next occurrence of f\n {}\n}\n\n/*!\n * @brief string escaping as described in RFC 6901 (Sect. 4)\n * @param[in] s string to escape\n * @return escaped string\n *\n * Note the order of escaping \"~\" to \"~0\" and \"/\" to \"~1\" is important.\n */\ntemplate\ninline StringType escape(StringType s)\n{\n replace_substring(s, StringType{\"~\"}, StringType{\"~0\"});\n replace_substring(s, StringType{\"/\"}, StringType{\"~1\"});\n return s;\n}\n\n/*!\n * @brief string unescaping as described in RFC 6901 (Sect. 4)\n * @param[in] s string to unescape\n * @return unescaped string\n *\n * Note the order of escaping \"~1\" to \"/\" and \"~0\" to \"~\" is important.\n */\ntemplate\nstatic void unescape(StringType& s)\n{\n replace_substring(s, StringType{\"~1\"}, StringType{\"/\"});\n replace_substring(s, StringType{\"~0\"}, StringType{\"~\"});\n}\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // size_t\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\n/// struct to capture the start position of the current token\nstruct position_t\n{\n /// the total number of characters read\n std::size_t chars_read_total = 0;\n /// the number of characters read in the current line\n std::size_t chars_read_current_line = 0;\n /// the number of lines read\n std::size_t lines_read = 0;\n\n /// conversion to size_t to preserve SAX interface\n constexpr operator size_t() const\n {\n return chars_read_total;\n }\n};\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-FileCopyrightText: 2018 The Abseil Authors\n// SPDX-License-Identifier: MIT\n\n\n\n#include // array\n#include // size_t\n#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type\n#include // index_sequence, make_index_sequence, index_sequence_for\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\ntemplate\nusing uncvref_t = typename std::remove_cv::type>::type;\n\n#ifdef JSON_HAS_CPP_14\n\n// the following utilities are natively available in C++14\nusing std::enable_if_t;\nusing std::index_sequence;\nusing std::make_index_sequence;\nusing std::index_sequence_for;\n\n#else\n\n// alias templates to reduce boilerplate\ntemplate\nusing enable_if_t = typename std::enable_if::type;\n\n// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h\n// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0.\n\n//// START OF CODE FROM GOOGLE ABSEIL\n\n// integer_sequence\n//\n// Class template representing a compile-time integer sequence. An instantiation\n// of `integer_sequence` has a sequence of integers encoded in its\n// type through its template arguments (which is a common need when\n// working with C++11 variadic templates). `absl::integer_sequence` is designed\n// to be a drop-in replacement for C++14's `std::integer_sequence`.\n//\n// Example:\n//\n// template< class T, T... Ints >\n// void user_function(integer_sequence);\n//\n// int main()\n// {\n// // user_function's `T` will be deduced to `int` and `Ints...`\n// // will be deduced to `0, 1, 2, 3, 4`.\n// user_function(make_integer_sequence());\n// }\ntemplate \nstruct integer_sequence\n{\n using value_type = T;\n static constexpr std::size_t size() noexcept\n {\n return sizeof...(Ints);\n }\n};\n\n// index_sequence\n//\n// A helper template for an `integer_sequence` of `size_t`,\n// `absl::index_sequence` is designed to be a drop-in replacement for C++14's\n// `std::index_sequence`.\ntemplate \nusing index_sequence = integer_sequence;\n\nnamespace utility_internal\n{\n\ntemplate \nstruct Extend;\n\n// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency.\ntemplate \nstruct Extend, SeqSize, 0>\n{\n using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >;\n};\n\ntemplate \nstruct Extend, SeqSize, 1>\n{\n using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >;\n};\n\n// Recursion helper for 'make_integer_sequence'.\n// 'Gen::type' is an alias for 'integer_sequence'.\ntemplate \nstruct Gen\n{\n using type =\n typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type;\n};\n\ntemplate \nstruct Gen\n{\n using type = integer_sequence;\n};\n\n} // namespace utility_internal\n\n// Compile-time sequences of integers\n\n// make_integer_sequence\n//\n// This template alias is equivalent to\n// `integer_sequence`, and is designed to be a drop-in\n// replacement for C++14's `std::make_integer_sequence`.\ntemplate \nusing make_integer_sequence = typename utility_internal::Gen::type;\n\n// make_index_sequence\n//\n// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`,\n// and is designed to be a drop-in replacement for C++14's\n// `std::make_index_sequence`.\ntemplate \nusing make_index_sequence = make_integer_sequence;\n\n// index_sequence_for\n//\n// Converts a typename pack into an index sequence of the same length, and\n// is designed to be a drop-in replacement for C++14's\n// `std::index_sequence_for()`\ntemplate \nusing index_sequence_for = make_index_sequence;\n\n//// END OF CODE FROM GOOGLE ABSEIL\n\n#endif\n\n// dispatch utility (taken from ranges-v3)\ntemplate struct priority_tag : priority_tag < N - 1 > {};\ntemplate<> struct priority_tag<0> {};\n\n// taken from ranges-v3\ntemplate\nstruct static_const\n{\n static JSON_INLINE_VARIABLE constexpr T value{};\n};\n\n#ifndef JSON_HAS_CPP_17\n template\n constexpr T static_const::value;\n#endif\n\ntemplate\ninline constexpr std::array make_array(Args&& ... args)\n{\n return std::array {{static_cast(std::forward(args))...}};\n}\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // numeric_limits\n#include // false_type, is_constructible, is_integral, is_same, true_type\n#include // declval\n#include // tuple\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n#include // random_access_iterator_tag\n\n// #include \n\n// #include \n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\nnamespace detail\n{\n\ntemplate\nstruct iterator_types {};\n\ntemplate\nstruct iterator_types <\n It,\n void_t>\n{\n using difference_type = typename It::difference_type;\n using value_type = typename It::value_type;\n using pointer = typename It::pointer;\n using reference = typename It::reference;\n using iterator_category = typename It::iterator_category;\n};\n\n// This is required as some compilers implement std::iterator_traits in a way that\n// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.\ntemplate\nstruct iterator_traits\n{\n};\n\ntemplate\nstruct iterator_traits < T, enable_if_t < !std::is_pointer::value >>\n : iterator_types\n{\n};\n\ntemplate\nstruct iterator_traits::value>>\n{\n using iterator_category = std::random_access_iterator_tag;\n using value_type = T;\n using difference_type = ptrdiff_t;\n using pointer = T*;\n using reference = T&;\n};\n\n} // namespace detail\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\n\nNLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin);\n\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n\n\n// #include \n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\n\nNLOHMANN_CAN_CALL_STD_FUNC_IMPL(end);\n\nNLOHMANN_JSON_NAMESPACE_END\n\n// #include \n\n// #include \n\n// #include \n// __ _____ _____ _____\n// __| | __| | | | JSON for Modern C++\n// | | |__ | | | | | | version 3.11.2\n// |_____|_____|_____|_|___| https://github.com/nlohmann/json\n//\n// SPDX-FileCopyrightText: 2013-2022 Niels Lohmann \n// SPDX-License-Identifier: MIT\n\n#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_\n #define INCLUDE_NLOHMANN_JSON_FWD_HPP_\n\n #include // int64_t, uint64_t\n #include // map\n #include // allocator\n #include // string\n #include // vector\n\n // #include \n\n\n /*!\n @brief namespace for Niels Lohmann\n @see https://github.com/nlohmann\n @since version 1.0.0\n */\n NLOHMANN_JSON_NAMESPACE_BEGIN\n\n /*!\n @brief default JSONSerializer template argument\n\n This serializer ignores the template arguments and uses ADL\n ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))\n for serialization.\n */\n template\n struct adl_serializer;\n\n /// a class to store JSON values\n /// @sa https://json.nlohmann.me/api/basic_json/\n template class ObjectType =\n std::map,\n template class ArrayType = std::vector,\n class StringType = std::string, class BooleanType = bool,\n class NumberIntegerType = std::int64_t,\n class NumberUnsignedType = std::uint64_t,\n class NumberFloatType = double,\n template class AllocatorType = std::allocator,\n template class JSONSerializer =\n adl_serializer,\n class BinaryType = std::vector>\n class basic_json;\n\n /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document\n /// @sa https://json.nlohmann.me/api/json_pointer/\n template\n class json_pointer;\n\n /*!\n @brief default specialization\n @sa https://json.nlohmann.me/api/json/\n */\n using json = basic_json<>;\n\n /// @brief a minimal map-like container that preserves insertion order\n /// @sa https://json.nlohmann.me/api/ordered_map/\n template\n struct ordered_map;\n\n /// @brief specialization that maintains the insertion order of object keys\n /// @sa https://json.nlohmann.me/api/ordered_json/\n using ordered_json = basic_json;\n\n NLOHMANN_JSON_NAMESPACE_END\n\n#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_\n\n\nNLOHMANN_JSON_NAMESPACE_BEGIN\n/*!\n@brief detail namespace with internal helper functions\n\nThis namespace collects functions that should not be exposed,\nimplementations of some @ref basic_json methods, and meta-programming helpers.\n\n@since version 2.1.0\n*/\nnamespace detail\n{\n\n/////////////\n// helpers //\n/////////////\n\n// Note to maintainers:\n//\n// Every trait in this file expects a non CV-qualified type.\n// The only exceptions are in the 'aliases for detected' section\n// (i.e. those of the form: decltype(T::member_function(std::declval())))\n//\n// In this case, T has to be properly CV-qualified to constraint the function arguments\n// (e.g. to_json(BasicJsonType&, const T&))\n\ntemplate struct is_basic_json : std::false_type {};\n\nNLOHMANN_BASIC_JSON_TPL_DECLARATION\nstruct is_basic_json : std::true_type {};\n\n// used by exceptions create() member functions\n// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t\n// false_type otherwise\ntemplate\nstruct is_basic_json_context :\n std::integral_constant < bool,\n is_basic_json::type>::type>::value\n || std::is_same::value >\n{};\n\n//////////////////////\n// json_ref helpers //\n//////////////////////\n\ntemplate\nclass json_ref;\n\ntemplate\nstruct is_json_ref : std::false_type {};\n\ntemplate\nstruct is_json_ref> : std::true_type {};\n\n//////////////////////////\n// aliases for detected //\n//////////////////////////\n\ntemplate\nusing mapped_type_t = typename T::mapped_type;\n\ntemplate\nusing key_type_t = typename T::key_type;\n\ntemplate\nusing value_type_t = typename T::value_type;\n\ntemplate\nusing difference_type_t = typename T::difference_type;\n\ntemplate\nusing pointer_t = typename T::pointer;\n\ntemplate\nusing reference_t = typename T::reference;\n\ntemplate\nusing iterator_category_t = typename T::iterator_category;\n\ntemplate\nusing to_json_function = decltype(T::to_json(std::declval()...));\n\ntemplate\nusing from_json_function = decltype(T::from_json(std::declval()...));\n\ntemplate\nusing get_template_function = decltype(std::declval().template get());\n\n// trait checking if JSONSerializer::from_json(json const&, udt&) exists\ntemplate\nstruct has_from_json : std::false_type {};\n\n// trait checking if j.get is valid\n// use this trait instead of std::is_constructible or std::is_convertible,\n// both rely on, or make use of implicit conversions, and thus fail when T\n// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)\ntemplate \nstruct is_getable\n{\n static constexpr bool value = is_detected::value;\n};\n\ntemplate\nstruct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >>\n{\n using serializer = typename BasicJsonType::template json_serializer;\n\n static constexpr bool value =\n is_detected_exact::value;\n};\n\n// This trait checks if JSONSerializer::from_json(json const&) exists\n// this overload is used for non-default-constructible user-defined-types\ntemplate\nstruct has_non_default_from_json : std::false_type {};\n\ntemplate\nstruct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >>\n{\n using serializer = typename BasicJsonType::template json_serializer;\n\n static constexpr bool value =\n is_detected_exact::value;\n};\n\n// This trait checks if BasicJsonType::json_serializer::to_json exists\n// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.\ntemplate\nstruct has_to_json : std::false_type {};\n\ntemplate\nstruct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >>\n{\n using serializer = typename BasicJsonType::template json_serializer;\n\n static constexpr bool value =\n is_detected_exact::value;\n};\n\ntemplate\nusing detect_key_compare = typename T::key_compare;\n\ntemplate\nstruct has_key_compare : std::integral_constant::value> {};\n\n// obtains the actual object key comparator\ntemplate\nstruct actual_object_comparator\n{\n using object_t = typename BasicJsonType::object_t;\n using object_comparator_t = typename BasicJsonType::default_object_comparator_t;\n using type = typename std::conditional < has_key_compare::value,\n typename object_t::key_compare, object_comparator_t>::type;\n};\n\ntemplate\nusing actual_object_comparator_t = typename actual_object_comparator::type;\n\n///////////////////\n// is_ functions //\n///////////////////\n\n// https://en.cppreference.com/w/cpp/types/conjunction\ntemplate struct conjunction : std::true_type { };\ntemplate struct conjunction : B { };\ntemplate\nstruct conjunction\n: std::conditional(B::value), conjunction, B>::type {};\n\n// https://en.cppreference.com/w/cpp/types/negation\ntemplate struct negation : std::integral_constant < bool, !B::value > { };\n\n// Reimplementation of is_constructible and is_default_constructible, due to them being broken for\n// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367).\n// This causes compile errors in e.g. clang 3.5 or gcc 4.9.\ntemplate \nstruct is_default_constructible : std::is_default_constructible {};\n\ntemplate \nstruct is_default_constructible>\n : conjunction, is_default_constructible> {};\n\ntemplate \nstruct is_default_constructible>\n : conjunction, is_default_constructible> {};\n\ntemplate \nstruct is_default_constructible>\n : conjunction...> {};\n\ntemplate \nstruct is_default_constructible>\n : conjunction...> {};\n\n\ntemplate \nstruct is_constructible : std::is_constructible {};\n\ntemplate \nstruct is_constructible> : is_default_constructible> {};\n\ntemplate \nstruct is_constructible> : is_default_constructible> {};\n\ntemplate \nstruct is_constructible> : is_default_constructible> {};\n\ntemplate \nstruct is_constructible> : is_default_constructible> {};\n\n\ntemplate\nstruct is_iterator_traits : std::false_type {};\n\ntemplate\nstruct is_iterator_traits>\n{\n private:\n using traits = iterator_traits;\n\n public:\n static constexpr auto value =\n is_detected::value &&\n is_detected::value &&\n is_detected::value &&\n is_detected::value &&\n is_detected::value;\n};\n\ntemplate\nstruct is_range\n{\n private:\n using t_ref = typename std::add_lvalue_reference::type;\n\n using iterator = detected_t;\n using sentinel = detected_t;\n\n // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator\n // and https://en.cppreference.com/w/cpp/iterator/sentinel_for\n // but reimplementing these would be too much work, as a lot of other concepts are used underneath\n static constexpr auto is_iterator_begin =\n is_iterator_traits>::value;\n\n public:\n static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin;\n};\n\ntemplate\nusing iterator_t = enable_if_t::value, result_of_begin())>>;\n\ntemplate\nusing range_value_t = value_type_t>>;\n\n// The following implementation of is_complete_type is taken from\n// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/\n// and is written by Xiang Fan who agreed to using it in this library.\n\ntemplate\nstruct is_complete_type : std::false_type {};\n\ntemplate\nstruct is_complete_type : std::true_type {};\n\ntemplate\nstruct is_compatible_object_type_impl : std::false_type {};\n\ntemplate\nstruct is_compatible_object_type_impl <\n BasicJsonType, CompatibleObjectType,\n enable_if_t < is_detected::value&&\n is_detected::value >>\n{\n using object_t = typename BasicJsonType::object_t;\n\n // macOS's is_constructible does not play well with nonesuch...\n static constexpr bool value =\n is_constructible::value &&\n is_constructible::value;\n};\n\ntemplate\nstruct is_compatible_object_type\n : is_compatible_object_type_impl {};\n\ntemplate\nstruct is_constructible_object_type_impl : std::false_type {};\n\ntemplate\nstruct is_constructible_object_type_impl <\n BasicJsonType, ConstructibleObjectType,\n enable_if_t < is_detected::value&&\n is_detected::value >>\n{\n using object_t = typename BasicJsonType::object_t;\n\n static constexpr bool value =\n (is_default_constructible::value &&\n (std::is_move_assignable::value ||\n std::is_copy_assignable::value) &&\n (is_constructible::value &&\n std::is_same <\n typename object_t::mapped_type,\n typename ConstructibleObjectType::mapped_type >::value)) ||\n (has_from_json::value ||\n has_non_default_from_json <\n BasicJsonType,\n typename ConstructibleObjectType::mapped_type >::value);\n};\n\ntemplate\nstruct is_constructible_object_type\n : is_constructible_object_type_impl {};\n\ntemplate\nstruct is_compatible_string_type\n{\n static constexpr auto value =\n is_constructible::value;\n};\n\ntemplate\nstruct is_constructible_string_type\n{\n // launder type through decltype() to fix compilation failure on ICPC\n#ifdef __INTEL_COMPILER\n using laundered_type = decltype(std::declval());\n#else\n using laundered_type = ConstructibleStringType;\n#endif\n\n static constexpr auto value =\n conjunction <\n is_constructible,\n is_detected_exact>::value;\n};\n\ntemplate\nstruct is_compatible_array_type_impl : std::false_type {};\n\ntemplate\nstruct is_compatible_array_type_impl <\n BasicJsonType, CompatibleArrayType,\n enable_if_t <\n is_detected::value&&\n is_iterator_traits>>::value&&\n// special case for types like std::filesystem::path whose iterator's value_type are themselves\n// c.f. https://github.com/nlohmann/json/pull/3073\n !std::is_same>::value >>\n{\n static constexpr bool value =\n is_constructible>::value;\n};\n\ntemplate\nstruct is_compatible_array_type\n : is_compatible_array_type_impl {};\n\ntemplate\nstruct is_constructible_array_type_impl : std::false_type {};\n\ntemplate\nstruct is_constructible_array_type_impl <\n BasicJsonType, ConstructibleArrayType,\n enable_if_t::value >>\n : std::true_type {};\n\ntemplate\nstruct is_constructible_array_type_impl <\n BasicJsonType, ConstructibleArrayType,\n enable_if_t < !std::is_same::value&&\n !is_compatible_string_type::value&&\n is_default_constructible::value&&\n(std::is_move_assignable::value ||\n std::is_copy_assignable::value)&&\nis_detected::value&&\nis_iterator_traits>>::value&&\nis_detected::value&&\n// special case for types like std::filesystem::path whose iterator's value_type are themselves\n// c.f. https://github.com/nlohmann/json/pull/3073\n!std::is_same>::value&&\n is_complete_type <\n detected_t>::value >>\n{\n using value_type = range_value_t;\n\n static constexpr bool value =\n std::is_same::value ||\n has_from_json::value ||\n has_non_default_from_json <\n BasicJsonType,\n value_type >::value;\n};\n\ntemplate\nstruct is_constructible_array_type\n : is_constructible_array_type_impl {};\n\ntemplate\nstruct is_compatible_integer_type_impl : std::false_type {};\n\ntemplate\nstruct is_compatible_integer_type_impl <\n RealIntegerType, CompatibleNumberIntegerType,\n enable_if_t < std::is_integral::value&&\n std::is_integral::value&&\n !std::is_same::value >>\n{\n // is there an assert somewhere on overflows?\n using RealLimits = std::numeric_limits;\n using CompatibleLimits = std::numeric_limits;\n\n static constexpr auto value =\n is_constructible::value &&\n CompatibleLimits::is_integer &&\n RealLimits::is_signed == CompatibleLimits::is_signed;\n};\n\ntemplate\nstruct is_compatible_integer_type\n : is_compatible_integer_type_impl {};\n\ntemplate\nstruct is_compatible_type_impl: std::false_type {};\n\ntemplate\nstruct is_compatible_type_impl <\n BasicJsonType, CompatibleType,\n enable_if_t::value >>\n{\n static constexpr bool value =\n has_to_json::value;\n};\n\ntemplate\nstruct is_compatible_type\n : is_compatible_type_impl {};\n\ntemplate\nstruct is_constructible_tuple : std::false_type {};\n\ntemplate\nstruct is_constructible_tuple> : conjunction...> {};\n\ntemplate\nstruct is_json_iterator_of : std::false_type {};\n\ntemplate\nstruct is_json_iterator_of : std::true_type {};\n\ntemplate\nstruct is_json_iterator_of : std::true_type\n{};\n\n// checks if a given type T is a template specialization of Primary\ntemplate