Showing preview only (5,585K chars total). Download the full file or copy to clipboard to get everything.
Repository: NVIDIA-ISAAC-ROS/isaac_ros_nitros
Branch: main
Commit: 4fbeb113fdf9
Files: 770
Total size: 5.1 MB
Directory structure:
gitextract_a_s3rfnt/
├── .gitattributes
├── .gitignore
├── LICENSE
├── README.md
├── SECURITY.md
├── isaac_ros_gxf/
│ ├── CMakeLists.txt
│ ├── cmake/
│ │ ├── isaac_ros_gxf-extras.cmake
│ │ └── modules/
│ │ └── FindGXF.cmake
│ ├── gxf/
│ │ ├── AMENT_IGNORE
│ │ └── core/
│ │ └── include/
│ │ ├── common/
│ │ │ ├── assert.hpp
│ │ │ ├── backtrace.hpp
│ │ │ ├── byte.hpp
│ │ │ ├── endian.hpp
│ │ │ ├── expected.hpp
│ │ │ ├── fixed_map.hpp
│ │ │ ├── fixed_string.hpp
│ │ │ ├── fixed_vector.hpp
│ │ │ ├── iterator.hpp
│ │ │ ├── logger.hpp
│ │ │ ├── memory_utils.hpp
│ │ │ ├── nvtx_helper.hpp
│ │ │ ├── singleton.hpp
│ │ │ ├── span.hpp
│ │ │ ├── strong_type.hpp
│ │ │ ├── type_name.hpp
│ │ │ ├── type_name_gnuc.hpp
│ │ │ ├── type_utils.hpp
│ │ │ ├── unique_index_map.hpp
│ │ │ └── yaml_parser.hpp
│ │ ├── dlpack/
│ │ │ └── dlpack.h
│ │ ├── gxf/
│ │ │ ├── app/
│ │ │ │ ├── application.hpp
│ │ │ │ ├── arg.hpp
│ │ │ │ ├── arg_parse.hpp
│ │ │ │ ├── config_parser.hpp
│ │ │ │ ├── driver.hpp
│ │ │ │ ├── entity_group.hpp
│ │ │ │ ├── extension_manager.hpp
│ │ │ │ ├── graph_entity.hpp
│ │ │ │ ├── graph_utils.hpp
│ │ │ │ ├── proxy_component.hpp
│ │ │ │ ├── segment.hpp
│ │ │ │ └── worker.hpp
│ │ │ ├── behavior_tree/
│ │ │ │ ├── constant_behavior.hpp
│ │ │ │ ├── entity_count_failure_repeat_controller.hpp
│ │ │ │ ├── parallel_behavior.hpp
│ │ │ │ ├── repeat_behavior.hpp
│ │ │ │ ├── selector_behavior.hpp
│ │ │ │ ├── sequence_behavior.hpp
│ │ │ │ ├── switch_behavior.hpp
│ │ │ │ └── timer_behavior.hpp
│ │ │ ├── core/
│ │ │ │ ├── common_expected_macro.hpp
│ │ │ │ ├── component.hpp
│ │ │ │ ├── entity.hpp
│ │ │ │ ├── expected.hpp
│ │ │ │ ├── expected_macro.hpp
│ │ │ │ ├── filepath.hpp
│ │ │ │ ├── gxf.h
│ │ │ │ ├── gxf_ext.h
│ │ │ │ ├── handle.hpp
│ │ │ │ ├── parameter.hpp
│ │ │ │ ├── parameter_parser.hpp
│ │ │ │ ├── parameter_parser_std.hpp
│ │ │ │ ├── parameter_registrar.hpp
│ │ │ │ ├── parameter_storage.hpp
│ │ │ │ ├── parameter_wrapper.hpp
│ │ │ │ ├── registrar.hpp
│ │ │ │ ├── resource.hpp
│ │ │ │ ├── resource_manager.hpp
│ │ │ │ ├── resource_registrar.hpp
│ │ │ │ └── type_registry.hpp
│ │ │ ├── cuda/
│ │ │ │ ├── cuda_allocator.hpp
│ │ │ │ ├── cuda_buffer.hpp
│ │ │ │ ├── cuda_common.hpp
│ │ │ │ ├── cuda_event.hpp
│ │ │ │ ├── cuda_scheduling_terms.hpp
│ │ │ │ ├── cuda_stream.hpp
│ │ │ │ ├── cuda_stream_id.hpp
│ │ │ │ ├── cuda_stream_pool.hpp
│ │ │ │ ├── cuda_stream_sync.hpp
│ │ │ │ ├── stream_ordered_allocator.hpp
│ │ │ │ └── tests/
│ │ │ │ ├── convolution.h
│ │ │ │ ├── green_context_with_smid.h
│ │ │ │ └── test_cuda_helper.hpp
│ │ │ ├── logger/
│ │ │ │ ├── gxf_logger.hpp
│ │ │ │ └── logger.hpp
│ │ │ ├── multimedia/
│ │ │ │ ├── audio.hpp
│ │ │ │ ├── camera.hpp
│ │ │ │ └── video.hpp
│ │ │ ├── network/
│ │ │ │ ├── tcp_client.hpp
│ │ │ │ ├── tcp_client_socket.hpp
│ │ │ │ ├── tcp_codelet.hpp
│ │ │ │ ├── tcp_server.hpp
│ │ │ │ └── tcp_server_socket.hpp
│ │ │ ├── npp/
│ │ │ │ ├── nppi_mul_c.hpp
│ │ │ │ └── nppi_set.hpp
│ │ │ ├── rmm/
│ │ │ │ └── rmm_allocator.hpp
│ │ │ ├── serialization/
│ │ │ │ ├── component_serializer.hpp
│ │ │ │ ├── endpoint.hpp
│ │ │ │ ├── entity_recorder.hpp
│ │ │ │ ├── entity_replayer.hpp
│ │ │ │ ├── entity_serializer.hpp
│ │ │ │ ├── file.hpp
│ │ │ │ ├── file_stream.hpp
│ │ │ │ ├── serialization_buffer.hpp
│ │ │ │ ├── std_component_serializer.hpp
│ │ │ │ ├── std_entity_id_serializer.hpp
│ │ │ │ ├── std_entity_serializer.hpp
│ │ │ │ ├── tests/
│ │ │ │ │ └── serialization_tester.hpp
│ │ │ │ └── tid_hash.hpp
│ │ │ ├── std/
│ │ │ │ ├── allocator.hpp
│ │ │ │ ├── async_buffer_receiver.hpp
│ │ │ │ ├── async_buffer_transmitter.hpp
│ │ │ │ ├── block_memory_pool.hpp
│ │ │ │ ├── clock.hpp
│ │ │ │ ├── codelet.hpp
│ │ │ │ ├── complex.hpp
│ │ │ │ ├── component_allocator.hpp
│ │ │ │ ├── component_factory.hpp
│ │ │ │ ├── controller.hpp
│ │ │ │ ├── cpu_thread.hpp
│ │ │ │ ├── cuda_green_context.hpp
│ │ │ │ ├── cuda_green_context_pool.hpp
│ │ │ │ ├── default_extension.hpp
│ │ │ │ ├── dlpack_utils.hpp
│ │ │ │ ├── double_buffer_receiver.hpp
│ │ │ │ ├── double_buffer_transmitter.hpp
│ │ │ │ ├── eos.hpp
│ │ │ │ ├── event_based_scheduler.hpp
│ │ │ │ ├── extension.hpp
│ │ │ │ ├── extension_factory_helper.hpp
│ │ │ │ ├── gems/
│ │ │ │ │ ├── event_list/
│ │ │ │ │ │ ├── event_list.hpp
│ │ │ │ │ │ └── unique_event_list.hpp
│ │ │ │ │ ├── queue_thread/
│ │ │ │ │ │ └── queue_thread.hpp
│ │ │ │ │ ├── staging_queue/
│ │ │ │ │ │ ├── staging_queue.hpp
│ │ │ │ │ │ └── staging_queue_iterator.hpp
│ │ │ │ │ ├── suballocators/
│ │ │ │ │ │ ├── first_fit_allocator.hpp
│ │ │ │ │ │ └── first_fit_allocator_base.hpp
│ │ │ │ │ ├── timed_job_list/
│ │ │ │ │ │ └── timed_job_list.hpp
│ │ │ │ │ ├── utils/
│ │ │ │ │ │ └── time.hpp
│ │ │ │ │ └── video_buffer/
│ │ │ │ │ └── allocator.hpp
│ │ │ │ ├── graph_driver.hpp
│ │ │ │ ├── graph_driver_worker_common.hpp
│ │ │ │ ├── graph_worker.hpp
│ │ │ │ ├── greedy_scheduler.hpp
│ │ │ │ ├── ipc_client.hpp
│ │ │ │ ├── ipc_server.hpp
│ │ │ │ ├── memory_buffer.hpp
│ │ │ │ ├── metric.hpp
│ │ │ │ ├── monitor.hpp
│ │ │ │ ├── multi_thread_scheduler.hpp
│ │ │ │ ├── network_context.hpp
│ │ │ │ ├── new_component_allocator.hpp
│ │ │ │ ├── queue.hpp
│ │ │ │ ├── receiver.hpp
│ │ │ │ ├── resources.hpp
│ │ │ │ ├── scheduler.hpp
│ │ │ │ ├── scheduling_condition.hpp
│ │ │ │ ├── scheduling_term.hpp
│ │ │ │ ├── scheduling_term_combiner.hpp
│ │ │ │ ├── scheduling_terms.hpp
│ │ │ │ ├── system.hpp
│ │ │ │ ├── tensor.hpp
│ │ │ │ ├── timestamp.hpp
│ │ │ │ ├── topic.hpp
│ │ │ │ ├── transmitter.hpp
│ │ │ │ ├── unbounded_allocator.hpp
│ │ │ │ ├── vault.hpp
│ │ │ │ └── yaml_file_loader.hpp
│ │ │ ├── stream/
│ │ │ │ ├── stream_nvsci.hpp
│ │ │ │ ├── stream_nvscisync.hpp
│ │ │ │ ├── stream_sync_id.hpp
│ │ │ │ └── tests/
│ │ │ │ └── test_gxf_stream_sync_cuda_helper.hpp
│ │ │ └── ucx/
│ │ │ ├── ucx_common.hpp
│ │ │ ├── ucx_component_serializer.hpp
│ │ │ ├── ucx_context.hpp
│ │ │ ├── ucx_entity_serializer.hpp
│ │ │ ├── ucx_receiver.hpp
│ │ │ ├── ucx_serialization_buffer.hpp
│ │ │ └── ucx_transmitter.hpp
│ │ └── third_party/
│ │ └── LICENSE.txt
│ ├── package.xml
│ └── src/
│ └── isaac_ros_gxf.cpp
├── isaac_ros_gxf_extensions/
│ ├── gxf_isaac_argus/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_atlas/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── atlas/
│ │ │ ├── composite_schema_server.hpp
│ │ │ └── pose_tree_frame.hpp
│ │ └── package.xml
│ ├── gxf_isaac_camera_utils/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── camera_utils/
│ │ │ ├── camera_info_synchronizer.cpp
│ │ │ ├── camera_info_synchronizer.hpp
│ │ │ ├── camera_utils.cpp
│ │ │ ├── stereo_camera_synchronizer.cpp
│ │ │ └── stereo_camera_synchronizer.hpp
│ │ └── package.xml
│ ├── gxf_isaac_cuda/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_flatscan_localization/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_gems/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ ├── gems/
│ │ │ │ ├── algorithm/
│ │ │ │ │ └── string_utils.hpp
│ │ │ │ ├── common/
│ │ │ │ │ ├── composite_schema_uid.hpp
│ │ │ │ │ └── pose_frame_uid.hpp
│ │ │ │ ├── composite/
│ │ │ │ │ ├── composite_from_tensor.hpp
│ │ │ │ │ ├── composite_view.hpp
│ │ │ │ │ ├── measure.hpp
│ │ │ │ │ ├── quantity.hpp
│ │ │ │ │ ├── schema.hpp
│ │ │ │ │ └── schema_tensor_archive.hpp
│ │ │ │ ├── coms/
│ │ │ │ │ └── socket.hpp
│ │ │ │ ├── control_types/
│ │ │ │ │ └── differential_drive.hpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── allocator/
│ │ │ │ │ │ ├── allocator_base.hpp
│ │ │ │ │ │ └── allocators.hpp
│ │ │ │ │ ├── assert.hpp
│ │ │ │ │ ├── buffers/
│ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ ├── buffer.hpp
│ │ │ │ │ │ └── traits.hpp
│ │ │ │ │ ├── byte.hpp
│ │ │ │ │ ├── constants.hpp
│ │ │ │ │ ├── epsilon.hpp
│ │ │ │ │ ├── image/
│ │ │ │ │ │ └── image.hpp
│ │ │ │ │ ├── logger.hpp
│ │ │ │ │ ├── math/
│ │ │ │ │ │ ├── macros.hpp
│ │ │ │ │ │ ├── pose2.hpp
│ │ │ │ │ │ ├── pose3.hpp
│ │ │ │ │ │ ├── so2.hpp
│ │ │ │ │ │ ├── so3.hpp
│ │ │ │ │ │ ├── types.hpp
│ │ │ │ │ │ └── utils.hpp
│ │ │ │ │ ├── optional.hpp
│ │ │ │ │ └── tensor/
│ │ │ │ │ ├── sample_cloud.hpp
│ │ │ │ │ └── tensor.hpp
│ │ │ │ ├── cuda_utils/
│ │ │ │ │ ├── launch_utils.hpp
│ │ │ │ │ ├── stride_pointer.hpp
│ │ │ │ │ ├── stride_pointer_3d.hpp
│ │ │ │ │ └── vector_math.hpp
│ │ │ │ ├── flatscan/
│ │ │ │ │ ├── flatscan_info.hpp
│ │ │ │ │ └── flatscan_types.hpp
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── line.hpp
│ │ │ │ │ ├── line_segment.hpp
│ │ │ │ │ ├── line_utils.hpp
│ │ │ │ │ ├── n_cuboid.hpp
│ │ │ │ │ ├── n_sphere.hpp
│ │ │ │ │ ├── pinhole.hpp
│ │ │ │ │ ├── plane.hpp
│ │ │ │ │ ├── polygon.hpp
│ │ │ │ │ ├── polyline.hpp
│ │ │ │ │ └── types.hpp
│ │ │ │ ├── gxf_helpers/
│ │ │ │ │ ├── expected_macro_abstract.hpp
│ │ │ │ │ ├── expected_macro_common.hpp
│ │ │ │ │ ├── expected_macro_cuda.hpp
│ │ │ │ │ ├── expected_macro_gxf.hpp
│ │ │ │ │ ├── expected_macro_isaac.hpp
│ │ │ │ │ └── image_view.hpp
│ │ │ │ ├── image/
│ │ │ │ │ ├── color.hpp
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ └── utils.hpp
│ │ │ │ ├── pose_tree/
│ │ │ │ │ ├── pose_tree.hpp
│ │ │ │ │ └── pose_tree_edge_history.hpp
│ │ │ │ ├── serialization/
│ │ │ │ │ ├── base64.hpp
│ │ │ │ │ ├── json.hpp
│ │ │ │ │ └── json_formatter.hpp
│ │ │ │ ├── sight/
│ │ │ │ │ ├── sop.hpp
│ │ │ │ │ ├── sop_asset.hpp
│ │ │ │ │ ├── sop_image.hpp
│ │ │ │ │ ├── sop_mesh.hpp
│ │ │ │ │ ├── sop_point_cloud.hpp
│ │ │ │ │ ├── sop_style.hpp
│ │ │ │ │ ├── sop_text.hpp
│ │ │ │ │ └── sop_transform.hpp
│ │ │ │ ├── uuid/
│ │ │ │ │ └── uuid.hpp
│ │ │ │ └── video_buffer/
│ │ │ │ └── allocator.hpp
│ │ │ └── third_party/
│ │ │ └── nlohmann/
│ │ │ └── json.hpp
│ │ └── package.xml
│ ├── gxf_isaac_gxf_helpers/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── gxf_helpers/
│ │ │ ├── parameter_parser_isaac.hpp
│ │ │ ├── parameter_wrapper_isaac.hpp
│ │ │ └── string_provider.hpp
│ │ └── package.xml
│ ├── gxf_isaac_hesai/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_localization/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_message_compositor/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── message_compositor/
│ │ │ └── message_relay.hpp
│ │ └── package.xml
│ ├── gxf_isaac_messages/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── messages/
│ │ │ ├── accelerometer_message.hpp
│ │ │ ├── battery_state_message.hpp
│ │ │ ├── camera_message.hpp
│ │ │ ├── composite_message.hpp
│ │ │ ├── correlated_timestamp_message.hpp
│ │ │ ├── encoder_tick_message.hpp
│ │ │ ├── flatscan_message.hpp
│ │ │ ├── gyroscope_message.hpp
│ │ │ ├── helpers.hpp
│ │ │ ├── imu_message.hpp
│ │ │ ├── json_message.hpp
│ │ │ └── pose3d_cov_message.hpp
│ │ └── package.xml
│ ├── gxf_isaac_messages_throttler/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_optimizer/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── gxf_optimizer/
│ │ │ ├── common/
│ │ │ │ └── type.hpp
│ │ │ ├── core/
│ │ │ │ └── optimizer.hpp
│ │ │ └── exporter/
│ │ │ └── graph_types.hpp
│ │ └── package.xml
│ ├── gxf_isaac_point_cloud/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_range_scan_processing/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_ros_cuda/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_ros_messages/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── messages/
│ │ │ ├── flat_scan_message.hpp
│ │ │ └── point_cloud_message.hpp
│ │ └── package.xml
│ ├── gxf_isaac_segway/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_sight/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_timestamp_correlator/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ └── gxf_isaac_utils/
│ ├── CMakeLists.txt
│ ├── gxf/
│ │ └── extensions/
│ │ └── utils/
│ │ ├── disparity_to_depth.cpp
│ │ ├── disparity_to_depth.cu.cpp
│ │ ├── disparity_to_depth.cu.hpp
│ │ ├── disparity_to_depth.hpp
│ │ ├── image_loader.cpp
│ │ ├── image_loader.hpp
│ │ ├── udp_receiver.cpp
│ │ ├── udp_receiver.hpp
│ │ └── utils.cpp
│ └── package.xml
├── isaac_ros_managed_nitros/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── isaac_ros_managed_nitros/
│ │ ├── managed_nitros_message_filters_subscriber.hpp
│ │ ├── managed_nitros_publisher.hpp
│ │ └── managed_nitros_subscriber.hpp
│ └── package.xml
├── isaac_ros_managed_nitros_examples/
│ ├── custom_nitros_dnn_image_encoder/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── custom_nitros_dnn_image_encoder/
│ │ │ └── image_encoder_node.hpp
│ │ ├── launch/
│ │ │ └── custom_image_isaac_ros_dope_tensor_rt.launch.py
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── image_encoder_node.cpp
│ │ └── test/
│ │ ├── custom_nitros_dnn_image_encoder_pol.py
│ │ └── test_cases/
│ │ └── profile_image/
│ │ └── image.json
│ ├── custom_nitros_image/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── custom_nitros_image/
│ │ │ ├── gpu_image_builder_node.hpp
│ │ │ ├── gpu_image_viewer_node.hpp
│ │ │ └── nitros_image_switch_node.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── gpu_image_builder_node.cpp
│ │ │ ├── gpu_image_viewer_node.cpp
│ │ │ └── nitros_image_switch_node.cpp
│ │ └── test/
│ │ ├── custom_nitros_image_builder_pol.py
│ │ ├── custom_nitros_image_pol.py
│ │ ├── custom_nitros_image_viewer_pol.py
│ │ ├── test_cases/
│ │ │ └── profile_image/
│ │ │ └── image.json
│ │ └── test_nitros_image_switch_pol.py
│ ├── custom_nitros_message_filter/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── custom_nitros_message_filter/
│ │ │ └── synchronizer_node.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── synchronizer_node.cpp
│ │ └── test/
│ │ ├── custom_nitros_message_filter_pol.py
│ │ └── test_cases/
│ │ └── profile_image/
│ │ ├── camera_info.json
│ │ └── image.json
│ ├── custom_nitros_message_filter_interfaces/
│ │ ├── CMakeLists.txt
│ │ ├── msg/
│ │ │ └── SyncStatus.msg
│ │ └── package.xml
│ └── custom_nitros_string/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── custom_nitros_string/
│ │ ├── string_decoder_node.hpp
│ │ └── string_encoder_node.hpp
│ ├── package.xml
│ ├── src/
│ │ ├── string_decoder_node.cpp
│ │ └── string_encoder_node.cpp
│ └── test/
│ ├── custom_nitros_string_decoder_pol.py
│ ├── custom_nitros_string_encoder_pol.py
│ └── custom_nitros_string_pol.py
├── isaac_ros_nitros/
│ ├── CMakeLists.txt
│ ├── config/
│ │ └── type_adapter_nitros_context_graph.yaml
│ ├── include/
│ │ └── isaac_ros_nitros/
│ │ ├── nitros_context.hpp
│ │ ├── nitros_node.hpp
│ │ ├── nitros_publisher.hpp
│ │ ├── nitros_publisher_subscriber_base.hpp
│ │ ├── nitros_publisher_subscriber_group.hpp
│ │ ├── nitros_subscriber.hpp
│ │ └── types/
│ │ ├── nitros_empty.hpp
│ │ ├── nitros_format_agent.hpp
│ │ ├── nitros_type_base.hpp
│ │ ├── nitros_type_manager.hpp
│ │ ├── nitros_type_message_filter_traits.hpp
│ │ ├── nitros_type_view_factory.hpp
│ │ ├── type_adapter_nitros_context.hpp
│ │ └── type_utility.hpp
│ ├── lib/
│ │ ├── AMENT_IGNORE
│ │ ├── cuapriltags/
│ │ │ ├── cuapriltags/
│ │ │ │ └── cuAprilTags.h
│ │ │ ├── lib_aarch64_jetpack51/
│ │ │ │ └── libcuapriltags.a
│ │ │ ├── lib_aarch64_jetpack61/
│ │ │ │ └── libcuapriltags.a
│ │ │ └── lib_x86_64_cuda_12_6/
│ │ │ └── libcuapriltags.a
│ │ ├── cumotion/
│ │ │ ├── .gitattributes
│ │ │ ├── aarch64_jetpack70/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── NOTICE
│ │ │ │ ├── include/
│ │ │ │ │ └── cumotion/
│ │ │ │ │ ├── collision_free_ik_solver.h
│ │ │ │ │ ├── collision_sphere_generator.h
│ │ │ │ │ ├── composite_path_spec.h
│ │ │ │ │ ├── cspace_path.h
│ │ │ │ │ ├── cspace_path_spec.h
│ │ │ │ │ ├── cumotion.h
│ │ │ │ │ ├── cumotion_export.h
│ │ │ │ │ ├── ik_solver.h
│ │ │ │ │ ├── kinematics.h
│ │ │ │ │ ├── linear_cspace_path.h
│ │ │ │ │ ├── motion_planner.h
│ │ │ │ │ ├── obstacle.h
│ │ │ │ │ ├── path_conversion.h
│ │ │ │ │ ├── path_spec_yaml.h
│ │ │ │ │ ├── pose3.h
│ │ │ │ │ ├── rmpflow.h
│ │ │ │ │ ├── robot_description.h
│ │ │ │ │ ├── robot_segmenter.h
│ │ │ │ │ ├── robot_world_inspector.h
│ │ │ │ │ ├── rotation3.h
│ │ │ │ │ ├── task_space_path.h
│ │ │ │ │ ├── task_space_path_spec.h
│ │ │ │ │ ├── text_style.h
│ │ │ │ │ ├── trajectory.h
│ │ │ │ │ ├── trajectory_generator.h
│ │ │ │ │ ├── trajectory_optimizer.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ ├── vision.h
│ │ │ │ │ ├── world.h
│ │ │ │ │ └── world_inspector.h
│ │ │ │ ├── lib/
│ │ │ │ │ ├── cmake/
│ │ │ │ │ │ └── cumotion/
│ │ │ │ │ │ ├── cumotionConfig.cmake
│ │ │ │ │ │ ├── cumotionConfigVersion.cmake
│ │ │ │ │ │ ├── cumotionTargets-release.cmake
│ │ │ │ │ │ └── cumotionTargets.cmake
│ │ │ │ │ └── libcumotion.so.1.1.0
│ │ │ │ └── python_wheels/
│ │ │ │ ├── cumotion-1.1.0-cp312-cp312-linux_aarch64.whl
│ │ │ │ └── cumotion_vis-1.1.0-py3-none-any.whl
│ │ │ └── x86_64_cuda_13_0/
│ │ │ ├── LICENSE
│ │ │ ├── NOTICE
│ │ │ ├── include/
│ │ │ │ └── cumotion/
│ │ │ │ ├── collision_free_ik_solver.h
│ │ │ │ ├── collision_sphere_generator.h
│ │ │ │ ├── composite_path_spec.h
│ │ │ │ ├── cspace_path.h
│ │ │ │ ├── cspace_path_spec.h
│ │ │ │ ├── cumotion.h
│ │ │ │ ├── cumotion_export.h
│ │ │ │ ├── ik_solver.h
│ │ │ │ ├── kinematics.h
│ │ │ │ ├── linear_cspace_path.h
│ │ │ │ ├── motion_planner.h
│ │ │ │ ├── obstacle.h
│ │ │ │ ├── path_conversion.h
│ │ │ │ ├── path_spec_yaml.h
│ │ │ │ ├── pose3.h
│ │ │ │ ├── rmpflow.h
│ │ │ │ ├── robot_description.h
│ │ │ │ ├── robot_segmenter.h
│ │ │ │ ├── robot_world_inspector.h
│ │ │ │ ├── rotation3.h
│ │ │ │ ├── task_space_path.h
│ │ │ │ ├── task_space_path_spec.h
│ │ │ │ ├── text_style.h
│ │ │ │ ├── trajectory.h
│ │ │ │ ├── trajectory_generator.h
│ │ │ │ ├── trajectory_optimizer.h
│ │ │ │ ├── version.h
│ │ │ │ ├── vision.h
│ │ │ │ ├── world.h
│ │ │ │ └── world_inspector.h
│ │ │ ├── lib/
│ │ │ │ ├── cmake/
│ │ │ │ │ └── cumotion/
│ │ │ │ │ ├── cumotionConfig.cmake
│ │ │ │ │ ├── cumotionConfigVersion.cmake
│ │ │ │ │ ├── cumotionTargets-release.cmake
│ │ │ │ │ └── cumotionTargets.cmake
│ │ │ │ └── libcumotion.so.1.1.0
│ │ │ └── python_wheels/
│ │ │ ├── cumotion-1.1.0-cp312-cp312-linux_x86_64.whl
│ │ │ └── cumotion_vis-1.1.0-py3-none-any.whl
│ │ └── cuvslam/
│ │ ├── .gitattributes
│ │ ├── include/
│ │ │ └── cuvslam/
│ │ │ ├── cuvslam.h
│ │ │ ├── cuvslam2.h
│ │ │ ├── ground_constraint.h
│ │ │ └── ground_constraint2.h
│ │ ├── lib_aarch64_jetpack61/
│ │ │ └── cuvslam_api_launcher
│ │ ├── lib_aarch64_jetpack70/
│ │ │ └── cuvslam_api_launcher
│ │ ├── lib_x86_64_cuda_12_6/
│ │ │ └── cuvslam_api_launcher
│ │ └── lib_x86_64_cuda_13_0/
│ │ └── cuvslam_api_launcher
│ ├── package.xml
│ ├── scripts/
│ │ └── diagnostic_viewer.py
│ ├── src/
│ │ ├── nitros_context.cpp
│ │ ├── nitros_node.cpp
│ │ ├── nitros_publisher.cpp
│ │ ├── nitros_publisher_subscriber_group.cpp
│ │ ├── nitros_subscriber.cpp
│ │ └── types/
│ │ ├── nitros_empty.cpp
│ │ ├── nitros_type_base.cpp
│ │ └── type_adapter_nitros_context.cpp
│ └── test/
│ ├── config/
│ │ └── test_forward_node.yaml
│ ├── isaac_ros_nitros_diagnostics_test_pol.py
│ ├── isaac_ros_nitros_multi_node_test_pol.py
│ ├── isaac_ros_nitros_test_pol.py
│ ├── src/
│ │ └── nitros_empty_forward_node.cpp
│ └── test_cases/
│ └── nitros_image/
│ └── profile/
│ ├── april_tag_detection_array.json
│ ├── camera_info.json
│ ├── image.json
│ └── ketchup.pcd
├── isaac_ros_nitros_bridge/
│ ├── .gitattributes
│ ├── .gitignore
│ ├── CONTRIBUTING.md
│ ├── LICENSE
│ ├── config/
│ │ ├── nitros_bridge_convert_forward.yaml
│ │ ├── nitros_bridge_forward.yaml
│ │ └── nitros_bridge_image_converter.yaml
│ ├── isaac_ros_nitros_bridge_ros2/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_bridge_ros2/
│ │ │ ├── image_converter_node.hpp
│ │ │ ├── ipc_buffer_manager.hpp
│ │ │ └── tensor_list_converter_node.hpp
│ │ ├── launch/
│ │ │ ├── isaac_ros_nitros_bridge_image_converter.launch.py
│ │ │ ├── isaac_ros_nitros_bridge_quickstart.launch.py
│ │ │ └── isaac_ros_nitros_bridge_tensor_list_converter.launch.py
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── image_converter_node.cpp
│ │ │ └── tensor_list_converter_node.cpp
│ │ └── test/
│ │ ├── isaac_ros_nitros_bridge_image_pol.py
│ │ ├── isaac_ros_nitros_bridge_tensor_list_pol.py
│ │ └── test_cases/
│ │ └── nitros_image/
│ │ └── profile/
│ │ └── image.json
│ ├── resources/
│ │ ├── quickstart.bag/
│ │ │ ├── metadata.yaml
│ │ │ ├── quickstart.bag_0.db3
│ │ │ └── quickstart.bag_0.db3.zstd
│ │ └── unet_sample_data_ros1.bag
│ └── scripts/
│ └── workspace-entrypoint.sh
├── isaac_ros_nitros_topic_tools/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── isaac_ros_nitros_topic_tools/
│ │ ├── isaac_ros_nitros_camera_drop_node.hpp
│ │ └── isaac_ros_nitros_topic_tools_common.hpp
│ ├── launch/
│ │ └── isaac_ros_nitros_camera_drop.launch.py
│ ├── package.xml
│ ├── src/
│ │ └── isaac_ros_nitros_camera_drop_node.cpp
│ └── test/
│ ├── isaac_ros_nitros_topic_tools_camera_drop_node_mode_0_test.py
│ ├── isaac_ros_nitros_topic_tools_camera_drop_node_mode_1_test.py
│ └── isaac_ros_nitros_topic_tools_camera_drop_node_mode_2_test.py
├── isaac_ros_nitros_type/
│ ├── isaac_ros_nitros_battery_state_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_battery_state_type/
│ │ │ └── nitros_battery_state.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_battery_state.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_battery_state_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_battery_state_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_battery_state/
│ │ └── profile/
│ │ └── battery_state.json
│ ├── isaac_ros_nitros_camera_info_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_camera_info_type/
│ │ │ ├── nitros_camera_info.hpp
│ │ │ └── nitros_camera_info_view.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_camera_info.cpp
│ │ │ └── nitros_camera_info_view.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_camera_info_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_camera_info_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_camera_info/
│ │ └── profile/
│ │ └── camera_info.json
│ ├── isaac_ros_nitros_compressed_image_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_compressed_image_type/
│ │ │ └── nitros_compressed_image.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_compressed_image.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_compressed_image_type_test_pol.py
│ │ └── src/
│ │ └── nitros_compressed_image_forward_node.cpp
│ ├── isaac_ros_nitros_compressed_video_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_compressed_video_type/
│ │ │ └── nitros_compressed_video.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_compressed_video.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_compressed_video_type_test_pol.py
│ │ └── src/
│ │ └── nitros_compressed_video_forward_node.cpp
│ ├── isaac_ros_nitros_correlated_timestamp_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_correlated_timestamp_type/
│ │ │ └── nitros_correlated_timestamp.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_correlated_timestamp.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_correlated_timestamp_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_correlated_timestamp_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_correlated_timestamp/
│ │ └── profile/
│ │ └── correlated_timestamp.json
│ ├── isaac_ros_nitros_detection2_d_array_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ ├── detectnet/
│ │ │ │ ├── detection2_d.hpp
│ │ │ │ └── detection2_d_array_message.hpp
│ │ │ └── isaac_ros_nitros_detection2_d_array_type/
│ │ │ └── nitros_detection2_d_array.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── detection2_d_array_message.cpp
│ │ │ └── nitros_detection2_d_array.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_detection2_d_array_type_test_pol.py
│ │ ├── src/
│ │ │ ├── detection2_d_test_ext.cpp
│ │ │ └── nitros_detection2_d_array_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_detection2_d_array/
│ │ └── profile/
│ │ └── nitros_detection2_d_array.json
│ ├── isaac_ros_nitros_detection3_d_array_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ ├── detection3_d_array_message/
│ │ │ │ └── detection3_d_array_message.hpp
│ │ │ └── isaac_ros_nitros_detection3_d_array_type/
│ │ │ └── nitros_detection3_d_array.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── detection3_d_array_message.cpp
│ │ │ └── nitros_detection3_d_array.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_detection3_d_array_type_test_pol.py
│ │ ├── src/
│ │ │ ├── detection3_d_test_ext.cpp
│ │ │ └── nitros_detection3_d_array_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_detection3_d_array/
│ │ └── profile/
│ │ └── nitros_detection3_d_array.json
│ ├── isaac_ros_nitros_disparity_image_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_disparity_image_type/
│ │ │ ├── nitros_disparity_image.hpp
│ │ │ └── nitros_disparity_image_builder.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_disparity_image.cpp
│ │ │ └── nitros_disparity_image_builder.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_disparity_image_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_disparity_image_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_disparity_image/
│ │ └── profile/
│ │ └── image.json
│ ├── isaac_ros_nitros_encoder_ticks_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_encoder_ticks_type/
│ │ │ └── nitros_encoder_ticks.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_encoder_ticks.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_encoder_ticks_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_encoder_ticks_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_encoder_ticks/
│ │ └── profile/
│ │ └── encoder_ticks.json
│ ├── isaac_ros_nitros_flat_scan_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_flat_scan_type/
│ │ │ └── nitros_flat_scan.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_flat_scan.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_flat_scan_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_flat_scan_forward_node.cpp
│ │ └── test_cases/
│ │ └── profile/
│ │ └── flat_scan.json
│ ├── isaac_ros_nitros_image_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_image_type/
│ │ │ ├── nitros_image.hpp
│ │ │ ├── nitros_image_builder.hpp
│ │ │ ├── nitros_image_details.hpp
│ │ │ └── nitros_image_view.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_image.cpp
│ │ │ ├── nitros_image_builder.cpp
│ │ │ └── nitros_image_view.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_image_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_image_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_image/
│ │ └── profile/
│ │ └── image.json
│ ├── isaac_ros_nitros_imu_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_imu_type/
│ │ │ └── nitros_imu.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_imu.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_imu_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_imu_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_imu/
│ │ └── profile/
│ │ └── imu.json
│ ├── isaac_ros_nitros_occupancy_grid_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_occupancy_grid_type/
│ │ │ └── nitros_occupancy_grid.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_occupancy_grid.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_occupancy_grid_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_occupancy_grid_forward_node.cpp
│ │ └── test_cases/
│ │ └── profile/
│ │ └── occupancy_grid.json
│ ├── isaac_ros_nitros_odometry_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_odometry_type/
│ │ │ └── nitros_odometry.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_odometry.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_odometry_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_odometry_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_odometry/
│ │ └── profile/
│ │ └── odometry.json
│ ├── isaac_ros_nitros_point_cloud_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_point_cloud_type/
│ │ │ ├── nitros_point_cloud.hpp
│ │ │ ├── nitros_point_cloud_builder.hpp
│ │ │ └── nitros_point_cloud_view.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_point_cloud.cpp
│ │ │ ├── nitros_point_cloud_builder.cpp
│ │ │ └── nitros_point_cloud_view.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_managed_nitros_point_cloud_type_test_pol.py
│ │ ├── isaac_ros_nitros_point_cloud_type_test_pol.py
│ │ ├── managed_nitros_point_cloud_forward_node.cpp
│ │ ├── src/
│ │ │ └── nitros_point_cloud_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_point_cloud/
│ │ └── profile/
│ │ └── ketchup.pcd
│ ├── isaac_ros_nitros_pose_array_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_pose_array_type/
│ │ │ └── nitros_pose_array.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_pose_array.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_pose_array_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_pose_array_forward_node.cpp
│ │ └── test_cases/
│ │ └── profile/
│ │ └── pose_array.json
│ ├── isaac_ros_nitros_pose_cov_stamped_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_pose_cov_stamped_type/
│ │ │ └── nitros_pose_cov_stamped.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_pose_cov_stamped.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_pose_cov_stamped_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_pose_cov_stamped_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_pose_cov_stamped/
│ │ └── profile/
│ │ └── pose_cov_stamped.json
│ ├── isaac_ros_nitros_std_msg_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_std_msg_type/
│ │ │ └── nitros_int64.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_int64.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_int64_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_int64_forward_node.cpp
│ │ └── test_cases/
│ │ └── profile/
│ │ └── pose_array.json
│ ├── isaac_ros_nitros_tensor_list_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_tensor_list_type/
│ │ │ ├── nitros_data_type.hpp
│ │ │ ├── nitros_tensor.hpp
│ │ │ ├── nitros_tensor_builder.hpp
│ │ │ ├── nitros_tensor_list.hpp
│ │ │ ├── nitros_tensor_list_builder.hpp
│ │ │ ├── nitros_tensor_list_view.hpp
│ │ │ └── nitros_tensor_shape.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_data_type.cpp
│ │ │ ├── nitros_tensor_builder.cpp
│ │ │ ├── nitros_tensor_list.cpp
│ │ │ ├── nitros_tensor_list_builder.cpp
│ │ │ └── nitros_tensor_list_view.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_tensor_list_type_test_pol.py
│ │ └── src/
│ │ └── nitros_tensor_list_forward_node.cpp
│ └── isaac_ros_nitros_twist_type/
│ ├── .vscode/
│ │ └── settings.json
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── isaac_ros_nitros_twist_type/
│ │ └── nitros_twist.hpp
│ ├── package.xml
│ ├── src/
│ │ └── nitros_twist.cpp
│ └── test/
│ ├── config/
│ │ └── test_forward_node.yaml
│ ├── isaac_ros_nitros_twist_type_test_pol.py
│ ├── src/
│ │ └── nitros_twist_forward_node.cpp
│ └── test_cases/
│ └── nitros_twist/
│ └── profile/
│ └── twist.json
└── isaac_ros_pynitros/
├── isaac_ros_pynitros/
│ ├── __init__.py
│ ├── examples/
│ │ ├── __init__.py
│ │ ├── pynitros_dnn_image_encoder_node.py
│ │ ├── pynitros_image_forward_node.py
│ │ ├── pynitros_message_filter_sync_node.py
│ │ ├── pynitros_point_cloud_forward_node.py
│ │ └── pynitros_tensor_list_forward_node.py
│ ├── isaac_ros_pynitros_message_filter.py
│ ├── isaac_ros_pynitros_publisher.py
│ ├── isaac_ros_pynitros_subscriber.py
│ ├── pynitros_type_builders/
│ │ ├── __init__.py
│ │ ├── pynitros_image_builder.py
│ │ ├── pynitros_point_cloud_builder.py
│ │ ├── pynitros_tensor_list_builder.py
│ │ └── pynitros_type_builder_base.py
│ ├── pynitros_type_views/
│ │ ├── __init__.py
│ │ ├── pynitros_image_view.py
│ │ ├── pynitros_point_cloud_view.py
│ │ ├── pynitros_tensor_list_view.py
│ │ └── pynitros_type_view_base.py
│ └── utils/
│ ├── __init__.py
│ ├── cpu_shared_mem.py
│ └── tensor_data_type.py
├── launch/
│ ├── isaac_ros_pynitros_dnn_image_encoder.launch.py
│ ├── isaac_ros_pynitros_quickstart.launch.py
│ └── isaac_ros_pynitros_to_nitros.launch.py
├── package.xml
├── resource/
│ └── isaac_ros_pynitros
├── setup.cfg
├── setup.py
└── test/
├── isaac_ros_pynitros_dnn_image_encoder.py
├── isaac_ros_pynitros_image_test.py
├── isaac_ros_pynitros_point_cloud_test.py
├── isaac_ros_pynitros_sync_test.py
├── isaac_ros_pynitros_tensor_list_test.py
├── test_cases/
│ ├── nitros_image/
│ │ └── profile/
│ │ └── image.json
│ └── nitros_point_cloud/
│ └── test_data/
│ └── ketchup.pcd
├── test_copyright.py
├── test_flake8.py
└── test_pep257.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
# Ignore Python files in linguist
*.py linguist-detectable=false
# Images
*.gif filter=lfs diff=lfs merge=lfs -text
*.jpg filter=lfs diff=lfs merge=lfs -text
*.png filter=lfs diff=lfs merge=lfs -text
*.psd filter=lfs diff=lfs merge=lfs -text
# Archives
*.gz filter=lfs diff=lfs merge=lfs -text
*.tar filter=lfs diff=lfs merge=lfs -text
*.zip filter=lfs diff=lfs merge=lfs -text
# Documents
*.pdf filter=lfs diff=lfs merge=lfs -text
# Numpy data
*.npy filter=lfs diff=lfs merge=lfs -text
# Debian package
*.deb filter=lfs diff=lfs merge=lfs -text
# Shared libraries
*.so.* filter=lfs diff=lfs merge=lfs -text
*.so filter=lfs diff=lfs merge=lfs -text
*.a filter=lfs diff=lfs merge=lfs -text
# trtexec
trtexec_x86_64 filter=lfs diff=lfs merge=lfs -text
================================================
FILE: .gitignore
================================================
# Ignore all pycache files
**/__pycache__/**
# Ignore ROS build files
**/build/**
**/install/**
**/cc_internals/**
**/log/**
================================================
FILE: LICENSE
================================================
NVIDIA ISAAC ROS SOFTWARE LICENSE
This 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”).
This license can be accepted only by an adult of legal age of majority in the country in which the SOFTWARE is used.
If 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.
If 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.
You 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.
1. 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:
a. Install and use the SOFTWARE,
b. Modify and create derivative works of sample or reference source code delivered in the SOFTWARE, and
c. 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.
2. DISTRIBUTION REQUIREMENTS. These are the distribution requirements for you to exercise the distribution grant above:
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.”
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.
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.
3. 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.
4. LIMITATIONS. Your license to use the SOFTWARE is restricted as follows:
a. The SOFTWARE is licensed for you to develop applications only for their use in systems with NVIDIA GPUs.
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.
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.
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.
e. You may not bypass, disable, or circumvent any technical limitation, encryption, security, digital rights management or authentication mechanism in the SOFTWARE.
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.
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.
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.
5. 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.
6. 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.
7. 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.
8. OWNERSHIP.
8.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.
8.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.
9. 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.
10. 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.
11. 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.
12. 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.
13. 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.
14. 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.
15. 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.
16. 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).
17. 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.
18. 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.
(v. November 17, 2021)
================================================
FILE: README.md
================================================
# Isaac ROS NITROS
NVIDIA Isaac Transport for ROS package for hardware-acceleration friendly movement of messages.
<div align="center"><a class="reference internal image-reference" href="https://media.githubusercontent.com/media/NVIDIA-ISAAC-ROS/.github/release-4.4/resources/isaac_ros_docs/repositories_and_packages/isaac_ros_nitros/image5-1.gif/"><img alt="image" src="https://media.githubusercontent.com/media/NVIDIA-ISAAC-ROS/.github/release-4.4/resources/isaac_ros_docs/repositories_and_packages/isaac_ros_nitros/image5-1.gif/" width="600px"/></a></div>
## Overview
Isaac ROS NITROS contains NVIDIA’s implementation
of type adaptation and negotiation in ROS 2. To learn more about NITROS, see [here](https://nvidia-isaac-ros.github.io/concepts/nitros/index.html).
Isaac ROS NITROS is composed of a number of individual packages, each with either a functional or structural purpose:
`isaac_ros_gxf`:
: This package serves as a container for precompiled GXF extensions used by other Isaac ROS packages.
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.
`isaac_ros_managed_nitros`:
: This package contains the wrapper classes that enable developers to add NITROS-compatible publishers and subscribers to third-party CUDA-based ROS nodes.
For more information about CUDA with NITROS, see [here](https://nvidia-isaac-ros.github.io/concepts/nitros/cuda_with_nitros.html).
`isaac_ros_nitros`:
: This package contains the base `NitrosNode` class and associated core utilities that serve as the foundation for all NITROS-based ROS nodes.
`isaac_ros_nitros_bridge`:
: This folder contains the implementation of the NITROS Bridge for inter-process communication.
`isaac_ros_nitros_interfaces`:
: This package contains the definitions of the custom ROS 2 interfaces that facilitate type negotiation between NITROS nodes.
`isaac_ros_nitros_topic_tools`:
: This folder contains a NITROS based implementation of some of the nodes in the [topic_tools package](https://github.com/ros-tooling/topic_tools).
`isaac_ros_nitros_type`:
: 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.
`isaac_ros_pynitros`:
: This folder contains the implementation of Python NITROS.
---
## Documentation
Please 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.
---
## Packages
* [`isaac_ros_gxf`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_gxf/index.html)
* [`isaac_ros_managed_nitros`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_managed_nitros/index.html)
* [`isaac_ros_nitros`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros/index.html)
* [Quickstart](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros/index.html#quickstart)
* [Isaac ROS NITROS Bridge](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html)
* [Overview](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#overview)
* [Performance](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#performance)
* [Packages](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#packages)
* [Quickstart](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#quickstart)
* [Try Another Example](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#try-another-example)
* [Troubleshooting](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#troubleshooting)
* [Updates](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_bridge/index.html#updates)
* [`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)
* [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)
* [`isaac_ros_nitros_topic_tools`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_topic_tools/index.html)
* [NitrosCameraDrop Node](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_topic_tools/index.html#nitroscameradrop-node)
* [`isaac_ros_nitros_type`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_nitros_type/index.html)
* [`isaac_ros_pynitros`](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html)
* [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)
* [Quickstart](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html#quickstart)
* [Try More Examples](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html#try-more-examples)
* [API Reference](https://nvidia-isaac-ros.github.io/repositories_and_packages/isaac_ros_nitros/isaac_ros_pynitros/index.html#api-reference)
## Latest
Update 2026-04-30: Compatibility and integration updates for the Isaac ROS 4.4.0 release
================================================
FILE: SECURITY.md
================================================
## Security
NVIDIA is dedicated to the security and trust of our software products and services, including all source code repositories managed through our organization.
If 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.
## Reporting Potential Security Vulnerability in an NVIDIA Product
To report a potential security vulnerability in any NVIDIA product:
- Web: [Security Vulnerability Submission Form](https://www.nvidia.com/object/submit-security-vulnerability.html)
- E-Mail: psirt@nvidia.com
- 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)
- Please include the following information:
- Product/Driver name and version/branch that contains the vulnerability
- Type of vulnerability (code execution, denial of service, buffer overflow, etc.)
- Instructions to reproduce the vulnerability
- Proof-of-concept or exploit code
- Potential impact of the vulnerability, including how an attacker could exploit the vulnerability
While 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.
## NVIDIA Product Security
For all security-related concerns, please visit NVIDIA's Product Security portal at https://www.nvidia.com/en-us/security
================================================
FILE: isaac_ros_gxf/CMakeLists.txt
================================================
# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
# Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
cmake_minimum_required(VERSION 3.22.1)
project(isaac_ros_gxf)
# Add option for overriding GXF core library directory
option(GXF_CORE_LIB_DIR_OVERRIDE "Override path for GXF core library directory" "")
execute_process(COMMAND uname -m COMMAND tr -d '\n' OUTPUT_VARIABLE ARCHITECTURE)
message( STATUS "Architecture: ${ARCHITECTURE}" )
find_package(ament_cmake_auto REQUIRED)
ament_auto_find_build_dependencies()
add_library(${PROJECT_NAME} STATIC src/isaac_ros_gxf.cpp)
# GXF core headers
install(
DIRECTORY gxf/core/include/
DESTINATION share/${PROJECT_NAME}/gxf/include/
)
# Install extensions directory
if( ${ARCHITECTURE} STREQUAL "x86_64" )
install(DIRECTORY gxf/core/lib/gxf_x86_64_cuda_13_0/ DESTINATION share/${PROJECT_NAME}/gxf/lib)
install(FILES gxf/core/lib/gxf_x86_64_cuda_13_0/core/libgxf_core.so DESTINATION lib)
install(FILES gxf/core/lib/gxf_x86_64_cuda_13_0/logger/libgxf_logger.so DESTINATION lib)
install(FILES gxf/core/lib/gxf_x86_64_cuda_13_0/multimedia/libgxf_multimedia.so DESTINATION lib)
install(FILES gxf/core/lib/gxf_x86_64_cuda_13_0/cuda/libgxf_cuda.so DESTINATION lib)
elseif( ${ARCHITECTURE} STREQUAL "aarch64" )
if(CMAKE_DEVICE STREQUAL "sbsa")
set(GXF_CORE_LIB_DIR gxf/core/lib/gxf_aarch64_cuda_13_0/)
elseif(CMAKE_DEVICE STREQUAL "arm64")
set(GXF_CORE_LIB_DIR gxf/core/lib/gxf_jetpack70/)
else()
message(FATAL_ERROR "Device is not supported.")
endif()
install(DIRECTORY ${GXF_CORE_LIB_DIR} DESTINATION share/${PROJECT_NAME}/gxf/lib)
install(FILES ${GXF_CORE_LIB_DIR}/core/libgxf_core.so DESTINATION lib)
install(FILES ${GXF_CORE_LIB_DIR}/logger/libgxf_logger.so DESTINATION lib)
install(FILES ${GXF_CORE_LIB_DIR}/multimedia/libgxf_multimedia.so DESTINATION lib)
install(FILES ${GXF_CORE_LIB_DIR}/cuda/libgxf_cuda.so DESTINATION lib)
endif()
# Register cmake in install.
ament_index_register_resource(isaac_ros_gxf_cmake_path CONTENT
"${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME}/cmake")
list(APPEND ${PROJECT_NAME}_CONFIG_EXTRAS cmake/isaac_ros_gxf-extras.cmake)
# Core
add_library(Core INTERFACE)
set_target_properties(Core PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/include"
)
set_property(TARGET Core PROPERTY
INTERFACE_LINK_LIBRARIES
magic_enum::magic_enum
"$<INSTALL_PREFIX>/lib/libgxf_core.so"
)
# Logger
add_library(Logger INTERFACE)
set_target_properties(Logger PROPERTIES
INTERFACE_LINK_LIBRARIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/lib/logger/libgxf_logger.so"
INTERFACE_INCLUDE_DIRECTORIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/include"
)
# Std
add_library(Std INTERFACE)
set_target_properties(Std PROPERTIES
INTERFACE_LINK_LIBRARIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/lib/std/libgxf_std.so"
INTERFACE_INCLUDE_DIRECTORIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/include"
)
# Multimedia
add_library(Multimedia INTERFACE)
set_target_properties(Multimedia PROPERTIES
INTERFACE_LINK_LIBRARIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/lib/multimedia/libgxf_multimedia.so"
INTERFACE_INCLUDE_DIRECTORIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/include"
)
# Serialization
add_library(Serialization INTERFACE)
set_target_properties(Serialization PROPERTIES
INTERFACE_LINK_LIBRARIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/lib/serialization/libgxf_serialization.so"
INTERFACE_INCLUDE_DIRECTORIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/include"
)
# Cuda
add_library(Cuda INTERFACE)
set_target_properties(Cuda PROPERTIES
INTERFACE_LINK_LIBRARIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/lib/cuda/libgxf_cuda.so"
INTERFACE_INCLUDE_DIRECTORIES
"$<INSTALL_PREFIX>/share/${PROJECT_NAME}/gxf/include"
)
install(TARGETS Core Logger Std Multimedia Serialization Cuda
EXPORT export_${PROJECT_NAME}
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
RUNTIME DESTINATION bin)
ament_export_targets(export_${PROJECT_NAME} HAS_LIBRARY_TARGET)
if(BUILD_TESTING)
find_package(ament_lint_auto REQUIRED)
# Ignore copyright notices since we use custom NVIDIA Isaac ROS Software License
set(ament_cmake_copyright_FOUND TRUE)
ament_lint_auto_find_test_dependencies()
endif()
# Embed versioning information into installed files
ament_index_get_resource(ISAAC_ROS_COMMON_CMAKE_PATH isaac_ros_common_cmake_path isaac_ros_common)
include("${ISAAC_ROS_COMMON_CMAKE_PATH}/isaac_ros_common-version-info.cmake")
generate_version_info(${PROJECT_NAME})
ament_auto_package(INSTALL_TO_SHARE cmake)
================================================
FILE: isaac_ros_gxf/cmake/isaac_ros_gxf-extras.cmake
================================================
# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
# Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
# Common flags and cmake commands for all Isaac ROS packages based on NITROS
message(STATUS "Loading isaac_ros_gxf extras")
# Append local cmake module path for CMAKE_MODULE_PATH
ament_index_get_resource(ISAAC_ROS_GXF_CMAKE_PATH isaac_ros_gxf_cmake_path isaac_ros_gxf)
list(APPEND CMAKE_MODULE_PATH "${ISAAC_ROS_GXF_CMAKE_PATH}/modules")
# Versions
set(ISAAC_ROS_GXF_VERSION 2.5.0)
================================================
FILE: isaac_ros_gxf/cmake/modules/FindGXF.cmake
================================================
# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
# Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0
# Create GXF imported cmake targets
#
# This module defines GXF_FOUND if all GXF libraries are found or
# if the required libraries (COMPONENTS property in find_package)
# are found.
#
# A new imported target is created for each component (library)
# under the GXF namespace (GXF::${component_name})
#
# Note: this leverages the find-module paradigm [1]. The config-file paradigm [2]
# is recommended instead in CMake.
# [1] https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#config-file-packages
# [2] https://cmake.org/cmake/help/latest/manual/cmake-packages.7.html#find-module-packages
# Library names
list(APPEND _GXF_EXTENSIONS
cuda
multimedia
serialization
std
)
list(APPEND GXF_BASE_PATHS "${isaac_ros_gxf_DIR}/../../../share/isaac_ros_gxf/gxf")
# Common headers
find_path(GXF_common_INCLUDE_DIR
NAMES common/
PATHS ${GXF_BASE_PATHS}
PATH_SUFFIXES include/
REQUIRED
)
mark_as_advanced(GXF_common_INCLUDE_DIR)
list(APPEND GXF_INCLUDE_DIR_VARS GXF_common_INCLUDE_DIR)
# Libraries and their headers
list(APPEND _GXF_LIBRARIES ${_GXF_EXTENSIONS} core)
foreach(component IN LISTS _GXF_LIBRARIES)
# headers
find_path(GXF_${component}_INCLUDE_DIR
NAMES "${component}/"
PATHS ${GXF_BASE_PATHS}
PATH_SUFFIXES
include
include/gxf
NO_DEFAULT_PATH
REQUIRED
)
mark_as_advanced(GXF_${component}_INCLUDE_DIR)
list(APPEND GXF_INCLUDE_DIR_VARS GXF_${component}_INCLUDE_DIR)
# library
find_library(GXF_${component}_LIBRARY
NAMES "gxf_${component}" "${component}"
PATHS ${GXF_BASE_PATHS}
PATH_SUFFIXES
lib/${component}
lib/${GXF_PLATFORM_SUFFIX}
lib/${GXF_PLATFORM_SUFFIX}/${component}
lib/${GXF_PLATFORM_SUFFIX}/isaac
lib/${GXF_PLATFORM_SUFFIX}/isaac/${component}
REQUIRED
)
mark_as_advanced(GXF_${component}_LIBRARY)
list(APPEND GXF_LIBRARY_VARS GXF_${component}_LIBRARY)
# create imported target
if(GXF_${component}_LIBRARY AND GXF_${component}_INCLUDE_DIR)
set(gxf_component_location "${GXF_${component}_LIBRARY}")
if(NOT TARGET GXF::${component})
# Assume SHARED, though technically UNKNOWN since we don't enforce .so
add_library(GXF::${component} SHARED IMPORTED)
endif()
list(APPEND GXF_${component}_INCLUDE_DIRS
${GXF_${component}_INCLUDE_DIR}
${GXF_${component}_INCLUDE_DIR}/${component}
${GXF_common_INCLUDE_DIR}
)
message(STATUS "Found ${component} lib=${gxf_component_location}, include=${GXF_${component}_INCLUDE_DIR}")
# Points to the copied location of GXF
set_target_properties(GXF::${component} PROPERTIES
IMPORTED_LOCATION "${gxf_component_location}"
IMPORTED_NO_SONAME ON
INTERFACE_INCLUDE_DIRECTORIES "${GXF_${component}_INCLUDE_DIRS}"
)
set(GXF_${component}_FOUND TRUE)
else()
message(FATAL_ERROR "Could not find GXF::${component}: lib={GXF_${component}_LIBRARY} / include=${GXF_${component}_INCLUDE_DIR}")
set(GXF_${component}_FOUND FALSE)
endif()
endforeach()
unset(_GXF_EXTENSIONS)
unset(_GXF_LIBRARIES)
# Find version
if(GXF_core_INCLUDE_DIR)
# Note: "kGxfCoreVersion \"(.*)\"$" does not work with a simple string
# REGEX (doesn't stop and EOL, neither $ nor \n), so we first extract
# the line with file(STRINGS), then the version with string(REGEX)
file(STRINGS "${GXF_core_INCLUDE_DIR}/core/gxf.h" _GXF_VERSION_LINE
REGEX "kGxfCoreVersion"
)
string(REGEX MATCH "kGxfCoreVersion \"(.*)\"" _ ${_GXF_VERSION_LINE})
set(GXF_VERSION ${CMAKE_MATCH_1})
unset(_GXF_VERSION_LINE)
endif()
# Generate GXF_FOUND
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(GXF
FOUND_VAR GXF_FOUND
VERSION_VAR GXF_VERSION
HANDLE_COMPONENTS # Looks for GXF_${component}_FOUND
)
================================================
FILE: isaac_ros_gxf/gxf/AMENT_IGNORE
================================================
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/assert.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_ASSERT_HPP_
#define NVIDIA_COMMON_ASSERT_HPP_
#include <cstdlib>
#include <cstring>
#include <string>
#include "common/backtrace.hpp"
#include "common/logger.hpp"
// Prints a panic message and aborts the program
#define GXF_PANIC(...) \
{ \
GXF_LOG_PANIC(__VA_ARGS__); \
PrettyPrintBacktrace(); \
std::exit(1); \
}
// Checks if an expression evaluates to true. If not prints a panic message and aborts the program.
#define GXF_ASSERT(expr, ...) \
if (!(expr)) { \
GXF_LOG_PANIC(__VA_ARGS__); \
PrettyPrintBacktrace(); \
std::exit(1); \
}
#define GXF_ASSERT_SUCCESS(expr) \
{ \
const auto _result = (expr); \
if (_result != 0) { \
GXF_LOG_PANIC("GXF operation failed: %s", GxfResultStr(_result)); \
PrettyPrintBacktrace(); \
std::exit(1); \
} \
} \
// Asserts that A == true. If not prints a panic message and aborts the program.
#define GXF_ASSERT_TRUE(exp_a) \
{ \
const auto _va = exp_a; \
GXF_ASSERT(_va == true, "Assert failed: %s == true.", std::to_string(_va).c_str()); \
}
// Asserts that A == false. If not prints a panic message and aborts the program.
#define GXF_ASSERT_FALSE(exp_a) \
{ \
const auto _va = exp_a; \
GXF_ASSERT(_va == false, "Assert failed: %s == false.", std::to_string(_va).c_str()); \
}
// Asserts that A == B. If not prints a panic message and aborts the program.
#define GXF_ASSERT_EQ(exp_a, exp_b) \
{ \
const auto _va = exp_a; \
const auto _vb = exp_b; \
GXF_ASSERT(_va == _vb, "Assert failed: %s == %s.", std::to_string(_va).c_str(), \
std::to_string(_vb).c_str()); \
}
// Asserts that A == B for two strings. If not prints a panic message and aborts the program.
#define GXF_ASSERT_STREQ(exp_a, exp_b) \
{ \
const char* _va = (exp_a); \
const char* _vb = (exp_b); \
GXF_ASSERT(std::strcmp(_va, _vb) == 0, "Assert failed: %s == %s.", _va, _vb); \
}
// Asserts that A != B. If not prints a panic message and aborts the program.
#define GXF_ASSERT_NE(exp_a, exp_b) \
{ \
const auto _va = exp_a; \
const auto _vb = exp_b; \
GXF_ASSERT(_va != _vb, "Assert failed: %s != %s.", std::to_string(_va).c_str(), \
std::to_string(_vb).c_str()); \
}
// Asserts that A > B. If not prints a panic message and aborts the program.
#define GXF_ASSERT_GT(exp_a, exp_b) \
{ \
const auto _va = exp_a; \
const auto _vb = exp_b; \
GXF_ASSERT(_va > _vb, "Assert failed: %s > %s.", std::to_string(_va).c_str(), \
std::to_string(_vb).c_str()); \
}
// Asserts that A >= B. If not prints a panic message and aborts the program.
#define GXF_ASSERT_GE(exp_a, exp_b) \
{ \
const auto _va = exp_a; \
const auto _vb = exp_b; \
GXF_ASSERT(_va >= _vb, "Assert failed: %s >= %s.", std::to_string(_va).c_str(), \
std::to_string(_vb).c_str()); \
}
// Asserts that A > B. If not prints a panic message and aborts the program.
#define GXF_ASSERT_LT(exp_a, exp_b) \
{ \
const auto _va = exp_a; \
const auto _vb = exp_b; \
GXF_ASSERT(_va < _vb, "Assert failed: %s > %s.", std::to_string(_va).c_str(), \
std::to_string(_vb).c_str()); \
}
// Asserts that A <= B. If not prints a panic message and aborts the program.
#define GXF_ASSERT_LE(exp_a, exp_b) \
{ \
const auto _va = exp_a; \
const auto _vb = exp_b; \
GXF_ASSERT(_va <= _vb, "Assert failed: %s <= %s.", std::to_string(_va).c_str(), \
std::to_string(_vb).c_str()); \
}
// Asserts that abs(A - B) <= abs_error. If not prints a panic message and aborts the program.
#define GXF_ASSERT_NEAR(exp_a, exp_b, exp_abs_error) \
{ \
const auto _va = exp_a; \
const auto _vb = exp_b; \
const auto _verror = exp_abs_error; \
GXF_ASSERT(std::abs(_va - _vb) <= _verror, "Assert failed: abs(%s - %s) <= %s.", \
std::to_string(_va).c_str(), std::to_string(_vb).c_str(), \
std::to_string(_verror).c_str()); \
}
#endif // NVIDIA_COMMON_ASSERT_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/backtrace.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_BACKTRACE_HPP_
#define NVIDIA_COMMON_BACKTRACE_HPP_
// Print the stacktrace with demangled function names (if possible)
// Function is disabled for QNX since execinfo.h is not available in the QNX toolchain
void PrettyPrintBacktrace();
#endif // NVIDIA_COMMON_BACKTRACE_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/byte.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_BYTE_HPP_
#define NVIDIA_COMMON_BYTE_HPP_
# if __cplusplus < 201703L
namespace std {
using byte = unsigned char;
} // namespace std
using std::byte;
# else
namespace nvidia {
using byte = unsigned char;
}
using nvidia::byte;
#endif
#endif // NVIDIA_COMMON_BYTE_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/endian.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_ENDIAN_HPP_
#define NVIDIA_COMMON_ENDIAN_HPP_
#ifdef _QNX_SOURCE
#include <net/netbyte.h>
#else
#include <endian.h>
#endif
#include "common/type_utils.hpp"
namespace nvidia {
/// Returns true if the machine stores multi-byte integers in little-endian format
/// FIXME: Use std::memcpy if reinterpret_cast has to be removed
inline bool IsLittleEndian() {
const uint16_t test = 0x0102;
return *reinterpret_cast<const uint8_t*>(&test) == 0x02;
}
/// Convert @a value to little-endian.
/// This overload should only be used if @c T is a signed integer type.
template <typename T, typename = EnableIf_t<IsIntegral_v<T>>>
inline T EncodeLittleEndian(T value) {
static_assert(IsSigned_v<T>);
using U = MakeUnsigned_t<T>;
return static_cast<T>(EncodeLittleEndian(static_cast<U>(value)));
}
template <> inline uint64_t EncodeLittleEndian<uint64_t>(uint64_t value) { return htole64(value); }
template <> inline uint32_t EncodeLittleEndian<uint32_t>(uint32_t value) { return htole32(value); }
template <> inline uint16_t EncodeLittleEndian<uint16_t>(uint16_t value) { return htole16(value); }
template <> inline uint8_t EncodeLittleEndian<uint8_t> (uint8_t value) { return value; }
/// Convert @a value from little-endian.
/// This overload should only be used if @c T is a signed integer type.
template <typename T, typename = EnableIf_t<IsIntegral_v<T>>>
inline T DecodeLittleEndian(T value) {
static_assert(IsSigned_v<T>);
using U = MakeUnsigned_t<T>;
return static_cast<T>(DecodeLittleEndian(static_cast<U>(value)));
}
template <> inline uint64_t DecodeLittleEndian<uint64_t>(uint64_t value) { return le64toh(value); }
template <> inline uint32_t DecodeLittleEndian<uint32_t>(uint32_t value) { return le32toh(value); }
template <> inline uint16_t DecodeLittleEndian<uint16_t>(uint16_t value) { return le16toh(value); }
template <> inline uint8_t DecodeLittleEndian<uint8_t> (uint8_t value) { return value; }
/// Returns true if the machine stores multi-byte integers in big-endian format
/// FIXME: Use std::memcpy if reinterpret_cast has to be removed
inline bool IsBigEndian() {
const uint16_t test = 0x0102;
return *reinterpret_cast<const uint8_t*>(&test) == 0x01;
}
/// Convert @a value to big-endian.
/// This overload should only be used if @c T is a signed integer type.
template <typename T, typename = EnableIf_t<IsIntegral_v<T>>>
inline T EncodeBigEndian(T value) {
static_assert(IsSigned_v<T>);
using U = MakeUnsigned_t<T>;
return static_cast<T>(EncodeBigEndian(static_cast<U>(value)));
}
template <> inline uint64_t EncodeBigEndian<uint64_t>(uint64_t value) { return htobe64(value); }
template <> inline uint32_t EncodeBigEndian<uint32_t>(uint32_t value) { return htobe32(value); }
template <> inline uint16_t EncodeBigEndian<uint16_t>(uint16_t value) { return htobe16(value); }
template <> inline uint8_t EncodeBigEndian<uint8_t> (uint8_t value) { return value; }
/// Convert @a value from big-endian.
/// This overload should only be used if @c T is a signed integer type.
template <typename T, typename = EnableIf_t<IsIntegral_v<T>>>
inline T DecodeBigEndian(T value) {
static_assert(IsSigned_v<T>);
using U = MakeUnsigned_t<T>;
return static_cast<T>(DecodeBigEndian(static_cast<U>(value)));
}
template <> inline uint64_t DecodeBigEndian<uint64_t>(uint64_t value) { return be64toh(value); }
template <> inline uint32_t DecodeBigEndian<uint32_t>(uint32_t value) { return be32toh(value); }
template <> inline uint16_t DecodeBigEndian<uint16_t>(uint16_t value) { return be16toh(value); }
template <> inline uint8_t DecodeBigEndian<uint8_t> (uint8_t value) { return value; }
} // namespace nvidia
#endif // NVIDIA_COMMON_ENDIAN_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/expected.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_EXPECTED_HPP_
#define NVIDIA_COMMON_EXPECTED_HPP_
#include <utility>
#include "common/assert.hpp"
#include "common/memory_utils.hpp"
#include "common/strong_type.hpp"
#include "common/type_utils.hpp"
namespace nvidia {
template <class E> using Unexpected = StrongType<struct Unexpected_t, E>;
template <class, class> class Expected;
///-------------------------------------------------------------------------------------------------
/// Local Helper Functions
///-------------------------------------------------------------------------------------------------
namespace detail {
template <class>
struct IsExpectedHelper : FalseType {};
template <class T, class E>
struct IsExpectedHelper<Expected<T, E>> : TrueType {};
template <class T>
using IsExpected = IsExpectedHelper<RemoveCVRef_t<T>>;
template <class T>
constexpr bool IsExpected_v = IsExpected<T>::value;
// Extracts the error type from a pack of Expecteds if they all contain the same Error .
template <class...>
struct ErrorTypeHelper : TypeIdentity<void> {};
template <class... Ts, class E>
struct ErrorTypeHelper<Expected<Ts, E>...> : TypeIdentity<E> {};
template <class... Ts>
using ErrorType = typename ErrorTypeHelper<RemoveCVRef_t<Ts>...>::type;
template <class E, class... Ts>
using ErrorTypeOr = Conditional_t<sizeof...(Ts) == 0, E, ErrorType<Ts...>>;
// Extracts the error type from a pack of Expecteds if they all contain the same Error .
template <class...>
struct ValueTypeHelper {};
template <class T, class E>
struct ValueTypeHelper<Expected<T, E>> { using type = T; };
template <class T>
using ValueType = typename ValueTypeHelper<RemoveCVRef_t<T>>::type;
// Extracts the type from a Unexpected if provided. Otherwise, returns the type T.
template <class T>
struct UnexpectedTypeHelper : TypeIdentity<T> {};
template <class T>
struct UnexpectedTypeHelper<Unexpected<T>> : TypeIdentity<T> {};
template <class T>
using UnexpectedType = typename UnexpectedTypeHelper<RemoveCVRef_t<T>>::type;
// Finds the result type of invoking a function with the wrapped types of a pack of Expecteds.
template <class F, class... Es>
using ResultType = decltype(Declval<F>()(Declval<Es>().value()...));
template <class F, class... Es>
using ErrorResultType = UnexpectedType<decltype(Declval<F>()(Declval<Es>().error()...))>;
// Empty struct for representing an object with only one possible value (itself). This can be used
// for speciallizing on void types where void would not compile because it is not a valid type.
// NOTE: GCC9 has a bug where it cannot evaluate the destructor of an empty struct, so put a dummy
// byte in to pass the compiler warnings. All empty structs are always considered non-zero in size
// in C++ anyway, and these are functionally equivalent for use with Expected<void>.
// https://www.stroustrup.com/bs_faq2.html#sizeof-empty
struct Unit { byte dummy; };
// If T is already Expected, keep as Expected, otherwise wrap as Expected<T, E>
template <class T, class E>
struct FlattenExpectedHelper : TypeIdentity<Expected<T, E>> {};
template <class T, class E>
struct FlattenExpectedHelper<Expected<T, E>, E> : TypeIdentity<Expected<T, E>> {};
template <class T, class E>
struct FlattenExpectedHelper<Expected<T, E>&, E>
: TypeIdentity<Expected<AddLvalueReference_t<T>, E>> {};
template <class T, class E>
struct FlattenExpectedHelper<const Expected<T, E>&, E>
: TypeIdentity<Expected<const AddLvalueReference_t<T>, E>> {};
template <class T, class E>
using FlattenExpected = typename FlattenExpectedHelper<T, E>::type;
// Helper for specializing on variadic parameter packs
template <class...> struct Pack {};
// Checks if a functor is callable with an Expected value.
template <class, class, class = void>
struct IsCallableHelper : FalseType {};
template <class F, class... Es>
struct IsCallableHelper<F, Pack<Es...>, void_t<ResultType<F, Es...>>> : TrueType {};
template <class F, class... Es>
struct IsCallable : IsCallableHelper<F, Pack<Es...>> {};
template <class F, class... Es>
constexpr bool IsCallable_v = IsCallable<F, Es...>::value;
// Checks if a functor is callable with an Expected value.
template <class, class, class = void>
struct IsErrorCallableHelper : FalseType {};
template <class F, class... Es>
struct IsErrorCallableHelper<F, Pack<Es...>, void_t<ErrorResultType<F, Es...>>> : TrueType {};
template <class F, class... Es>
struct IsErrorCallable : IsErrorCallableHelper<F, Pack<Es...>> {};
template <class F, class... Es>
constexpr bool IsErrorCallable_v = IsErrorCallable<F, Es...>::value;
// Maps the values with the given functor. If F returns an Expected, it returns the Expected type
// directly, otherwise it constructs a new Expected.
template <class E = void, class F, class... Args>
auto FunctorMap(F&& func, Args&&... expected) ->
EnableIf_t<!IsVoid_v<ResultType<F, Args...>>,
FlattenExpected<ResultType<F, Args...>, ErrorTypeOr<E, Args...>>> {
return std::forward<F>(func)(std::forward<Args>(expected).value()...);
}
// Maps the values with the given void functor. Returns Expected<void, Es...>.
template <class E = void, class F, class... Args>
auto FunctorMap(F&& func, Args&&... expected) ->
EnableIf_t<IsVoid_v<ResultType<F, Args...>>, Expected<void, ErrorTypeOr<E, Args...>>> {
std::forward<F>(func)(std::forward<Args>(expected).value()...);
return {};
}
// Maps the error values with the given function. If F returns an Unexpected, it returns the
// Unexpected type directly, otherwise it constructs a new Unexpected.
template <class F, class E>
Expected<ValueType<E>, ErrorResultType<F, E>> FunctorMapError(F&& func, E&& expected) {
using R = Unexpected<ErrorResultType<F, E>>;
return R{std::forward<F>(func)(std::forward<E>(expected).error())};
}
template <class T, class F>
Expected<T, ErrorResultType<F>> FunctorMapError(F&& func) {
using R = Unexpected<ErrorResultType<F>>;
return R{std::forward<F>(func)()};
}
// Base class for all operations of Expected, not directly related to setting or creating the value
// type T into the underlying byte buffer.
template <class T, class E, class Derived>
class ExpectedBase {
private:
static_assert(!IsVoid_v<T>, "ExpectedBase cannot wrap void types");
static_assert(!IsVoid_v<E>, "ExpectedBase cannot wrap void types");
static_assert(!IsReference_v<T>, "ExpectedBase cannot wrap reference types");
static_assert(!IsReference_v<E>, "ExpectedBase cannot wrap reference types");
template <class F, class U>
using EnableIfMappable_t =
EnableIf_t<IsCallable_v<F, U>, decltype(FunctorMap(Declval<F>(), Declval<U>()))>;
template <class F, class U>
using EnableIfNonaryMappable_t =
EnableIf_t<IsCallable_v<F> && !IsCallable_v<F, U>, FlattenExpected<ResultType<F>, E>>;
template <class F, class U>
using EnableIfMappableError_t =
EnableIf_t<IsErrorCallable_v<F, U>, decltype(FunctorMapError(Declval<F>(), Declval<U>()))>;
template <class F, class U>
using EnableIfNonaryMappableError_t =
EnableIf_t<IsErrorCallable_v<F> && !IsErrorCallable_v<F, U>,
Expected<T, ErrorResultType<F>>>;
public:
///-----------------------------------------------------------------------------------------------
/// Constructors
///-----------------------------------------------------------------------------------------------
constexpr ExpectedBase(const ExpectedBase& other) { constructFrom(other); }
constexpr ExpectedBase(ExpectedBase&& other) { constructFrom(std::move(other)); }
// Construction from convertible error types
template <class G, class C>
explicit constexpr ExpectedBase(const ExpectedBase<T, G, C>& other) {
static_assert(IsConvertible_v<G, E>,
"Cannot construct Expected from type with unconvertible error type.");
constructFrom(other);
}
template <class G, class C>
explicit constexpr ExpectedBase(ExpectedBase<T, G, C>&& other) {
static_assert(IsConvertible_v<G, E>,
"Cannot construct Expected from type with unconvertible error type.");
constructFrom(std::move(other));
}
template <class G>
constexpr ExpectedBase(const Unexpected<G>& error, const char* error_message = "")
: is_error_{true}, error_message_{error_message} {
static_assert(IsConvertible_v<G, E>,
"Cannot construct Unexpected from type with unconvertible error type.");
InplaceConstruct<Unexpected<E>>(buffer_, error.value());
}
template <class G>
constexpr ExpectedBase(Unexpected<G>&& error, const char* error_message = "")
: is_error_{true}, error_message_{error_message} {
static_assert(IsConvertible_v<G, E>,
"Cannot construct Unexpected from type with unconvertible error type.");
InplaceConstruct<Unexpected<E>>(buffer_, std::move(error.value()));
}
///-----------------------------------------------------------------------------------------------
/// Destructor
///-----------------------------------------------------------------------------------------------
~ExpectedBase() { destruct(); }
///-----------------------------------------------------------------------------------------------
/// Assignment
///-----------------------------------------------------------------------------------------------
ExpectedBase& operator=(const ExpectedBase& other) {
destruct();
constructFrom(other);
return *this;
}
ExpectedBase& operator=(ExpectedBase&& other) {
destruct();
constructFrom(std::move(other));
return *this;
}
template <class G>
ExpectedBase& operator=(const Unexpected<G>& error) {
destruct();
is_error_ = true;
InplaceConstruct<Unexpected<E>>(buffer_, error);
return *this;
}
template <class G>
ExpectedBase& operator=(Unexpected<G>&& error) {
destruct();
is_error_ = true;
InplaceConstruct<Unexpected<E>>(buffer_, std::move(error));
return *this;
}
///-----------------------------------------------------------------------------------------------
/// Observers
///-----------------------------------------------------------------------------------------------
template <class V = ValueType<Derived>, class D = const Derived>
constexpr EnableIf_t<!IsVoid_v<V>, RemoveReference_t<decltype(Declval<D*>()->value())>*>
operator->() const { return &(derived()->value()); }
template <class V = ValueType<Derived>, class D = Derived>
constexpr EnableIf_t<!IsVoid_v<V>, RemoveReference_t<decltype(Declval<D*>()->value())>*>
operator->() { return &(derived()->value()); }
template <class V = ValueType<Derived>>
constexpr EnableIf_t<!IsVoid_v<V>, const V&>
operator*() const& { return derived()->value(); }
template <class V = ValueType<Derived>>
constexpr EnableIf_t<!IsVoid_v<V>, V&>
operator*() & { return derived()->value(); }
template <class V = ValueType<Derived>, EnableIf_t<!IsVoid_v<V>, void*> = nullptr>
constexpr decltype(auto) operator*() const&& { return std::move(derived())->value(); }
template <class V = ValueType<Derived>, EnableIf_t<!IsVoid_v<V>, void*> = nullptr>
constexpr decltype(auto) operator*() && { return std::move(derived())->value(); }
template <class U, class V = ValueType<Derived>, EnableIf_t<!IsVoid_v<V>, void*> = nullptr>
constexpr V value_or(U&& default_value) const& {
return has_value() ? derived()->value() : std::forward<U>(default_value);
}
template <class U, class V = ValueType<Derived>, EnableIf_t<!IsVoid_v<V>, void*> = nullptr>
constexpr V value_or(U&& default_value) && {
return has_value() ? std::move(derived())->value() : std::forward<U>(default_value);
}
constexpr bool has_value() const { return !is_error_; }
constexpr explicit operator bool() const { return !is_error_; }
constexpr const E& error() const& { return unexpected().value(); }
constexpr E& error() & { return unexpected().value(); }
constexpr E&& error() && { return std::move(unexpected()).value(); }
constexpr const char* get_error_message() {
GXF_ASSERT(is_error_, "Expected does not have an error. Check before accessing.");
return error_message_;
}
///-----------------------------------------------------------------------------------------------
/// Logging
///-----------------------------------------------------------------------------------------------
// Logging helper functions if this contains an error value.
template <class... Args>
constexpr const Derived& log_error(Args&&... args) const& {
if (is_error_) { GXF_LOG_ERROR(std::forward<Args>(args)...); }
return static_cast<const Derived&>(*this);
}
template <class... Args>
constexpr Derived& log_error(Args&&... args) & {
if (is_error_) { GXF_LOG_ERROR(std::forward<Args>(args)...); }
return static_cast<Derived&>(*this);
}
template <class... Args>
constexpr Derived&& log_error(Args&&... args) && {
// GCC is not able to do format security validation when the string is coming from a
// variadic template, even if the string is originally a char*
// ignore this warning until a more recent GCC version fixes this behavior
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-security"
if (is_error_) { GXF_LOG_ERROR(std::forward<Args>(args)...); }
#pragma GCC diagnostic pop
return static_cast<Derived&&>(std::move(*this));
}
template <class... Args>
constexpr const Derived& log_warning(Args&&... args) const& {
if (is_error_) { GXF_LOG_WARNING(std::forward<Args>(args)...); }
return static_cast<const Derived&>(*this);
}
template <class... Args>
constexpr Derived& log_warning(Args&&... args) & {
if (is_error_) { GXF_LOG_WARNING(std::forward<Args>(args)...); }
return static_cast<Derived&>(*this);
}
template <class... Args>
constexpr Derived&& log_warning(Args&&... args) && {
if (is_error_) { GXF_LOG_WARNING(std::forward<Args>(args)...); }
return static_cast<Derived&&>(std::move(*this));
}
template <class... Args>
constexpr const Derived& log_info(Args&&... args) const& {
if (is_error_) { GXF_LOG_INFO(std::forward<Args>(args)...); }
return static_cast<const Derived&>(*this);
}
template <class... Args>
constexpr Derived& log_info(Args&&... args) & {
if (is_error_) { GXF_LOG_INFO(std::forward<Args>(args)...); }
return static_cast<Derived&>(*this);
}
template <class... Args>
constexpr Derived&& log_info(Args&&... args) && {
if (is_error_) { GXF_LOG_INFO(std::forward<Args>(args)...); }
return static_cast<Derived&&>(std::move(*this));
}
template <class... Args>
constexpr const Derived& log_debug(Args&&... args) const& {
if (is_error_) { GXF_LOG_DEBUG(std::forward<Args>(args)...); }
return static_cast<const Derived&>(*this);
}
template <class... Args>
constexpr Derived& log_debug(Args&&... args) & {
if (is_error_) { GXF_LOG_DEBUG(std::forward<Args>(args)...); }
return static_cast<Derived&>(*this);
}
template <class... Args>
constexpr Derived&& log_debug(Args&&... args) && {
if (is_error_) { GXF_LOG_DEBUG(std::forward<Args>(args)...); }
return static_cast<Derived&&>(std::move(*this));
}
///-----------------------------------------------------------------------------------------------
/// Substitute
///-----------------------------------------------------------------------------------------------
// When this expected does not contain an error an expected with the given value 'next' is
// created and returned, otherwise an unexpected with the error is returned.
template <class U>
constexpr FlattenExpected<U, E> substitute(U next) const& {
return has_value() ? FlattenExpected<U, E>{std::forward<U>(next)} : unexpected();
}
template <class U>
constexpr FlattenExpected<U, E> substitute(U next) && {
return has_value() ? FlattenExpected<U, E>{std::forward<U>(next)} : std::move(unexpected());
}
///-----------------------------------------------------------------------------------------------
/// Substitute Error
///-----------------------------------------------------------------------------------------------
template <class G>
constexpr Expected<ValueType<Derived>, G> substitute_error(G new_error) const& {
using R = Expected<ValueType<Derived>, G>;
return is_error_ ? R{Unexpected<G>{new_error}} : R{*ValuePointer<T>(buffer_)};
}
template <class G>
constexpr Expected<ValueType<Derived>, G> substitute_error(G new_error) && {
using R = Expected<ValueType<Derived>, G>;
return is_error_ ? R{Unexpected<G>{new_error}} : R{std::move(*ValuePointer<T>(buffer_))};
}
///-----------------------------------------------------------------------------------------------
/// Unary Free Functor Map
///-----------------------------------------------------------------------------------------------
// If in error the error is returned, otherwise the value is mapped with the given functor and
// the result is returned.
template <class F>
constexpr EnableIfMappable_t<F, Derived&> map(F&& func) & {
return has_value() ? FunctorMap(std::forward<F>(func), *derived()) : unexpected();
}
template <class F>
constexpr EnableIfMappable_t<F, const Derived&> map(F&& func) const& {
return has_value() ? FunctorMap(std::forward<F>(func), *derived()) : unexpected();
}
template <class F>
constexpr EnableIfMappable_t<F, Derived&&> map(F&& func) && {
return has_value() ? FunctorMap(std::forward<F>(func), std::move(*derived()))
: std::move(unexpected());
}
///-----------------------------------------------------------------------------------------------
/// Unary Free Functor Map Error
///-----------------------------------------------------------------------------------------------
// If has value the value is returned, otherwise the error is mapped with the given functor and
// the result is returned.
template <class F>
constexpr EnableIfMappableError_t<F, Derived&> map_error(F&& func) & {
using R = Expected<ValueType<Derived>, ErrorResultType<F, Derived&>>;
return is_error_ ? FunctorMapError(std::forward<F>(func), *derived())
: R{*ValuePointer<T>(buffer_)};
}
template <class F>
constexpr EnableIfMappableError_t<F, const Derived&> map_error(F&& func) const& {
using R = Expected<ValueType<Derived>, ErrorResultType<F, const Derived&>>;
return is_error_ ? FunctorMapError(std::forward<F>(func), *derived())
: R{*ValuePointer<T>(buffer_)};
}
template <class F>
constexpr EnableIfMappableError_t<F, Derived&&> map_error(F&& func) && {
using R = Expected<ValueType<Derived>, ErrorResultType<F, Derived&&>>;
return is_error_ ? FunctorMapError(std::forward<F>(func), std::move(*derived()))
: R{std::move(*ValuePointer<T>(buffer_))};
}
///-----------------------------------------------------------------------------------------------
/// Nonary Free Functor Map
///-----------------------------------------------------------------------------------------------
// If in error the error is returned, otherwise the given functor is called with no arguments and
// the result is returned.
template <class F>
constexpr EnableIfNonaryMappable_t<F, const Derived&> map(F&& func) const& {
return has_value() ? FunctorMap<E>(std::forward<F>(func)) : unexpected();
}
template <class F>
constexpr EnableIfNonaryMappable_t<F, const Derived&&> map(F&& func) && {
return has_value() ? FunctorMap<E>(std::forward<F>(func)) : std::move(unexpected());
}
template <class F>
constexpr FlattenExpected<ResultType<F>, E> and_then(F&& func) const& {
return has_value() ? FunctorMap<E>(std::forward<F>(func)) : unexpected();
}
template <class F>
constexpr FlattenExpected<ResultType<F>, E> and_then(F&& func) && {
return has_value() ? FunctorMap<E>(std::forward<F>(func)) : std::move(unexpected());
}
///-----------------------------------------------------------------------------------------------
/// Nonary Free Functor Map Error
///-----------------------------------------------------------------------------------------------
// If has value the value is returned, otherwise the given functor is called with no arguments and
// the result is returned.
template <class F>
constexpr EnableIfNonaryMappableError_t<F, const Derived&> map_error(F&& func) const& {
static_assert(IsErrorCallable_v<F>);
static_assert(!IsErrorCallable_v<F, const Derived&>);
using R = Expected<ValueType<Derived>, ErrorResultType<F>>;
return is_error_ ? FunctorMapError<T>(std::forward<F>(func)) : R{*ValuePointer<T>(buffer_)};
}
template <class F>
constexpr EnableIfNonaryMappableError_t<F, const Derived&&> map_error(F&& func) && {
using R = Expected<ValueType<Derived>, ErrorResultType<F>>;
return is_error_ ? FunctorMapError<T>(std::forward<F>(func))
: R{std::move(*ValuePointer<T>(buffer_))};
}
template <class F>
constexpr Expected<ValueType<Derived>, ErrorResultType<F>> and_then_error(F&& func) const& {
using R = Expected<ValueType<Derived>, ErrorResultType<F>>;
return is_error_ ? FunctorMapError<T>(std::forward<F>(func)) : R{*ValuePointer<T>(buffer_)};
}
template <class F>
constexpr Expected<ValueType<Derived>, ErrorResultType<F>> and_then_error(F&& func) && {
using R = Expected<ValueType<Derived>, ErrorResultType<F>>;
return is_error_ ? FunctorMapError<T>(std::forward<F>(func))
: R{std::move(*ValuePointer<T>(buffer_))};
}
///-----------------------------------------------------------------------------------------------
/// Member Variable Map
///-----------------------------------------------------------------------------------------------
template <class R, class U>
constexpr FlattenExpected<R&, E> map(R U::* ptr) & {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
// NOTE: We explicitly declare the return type of the lambda to allow capturing of member by
// mutable reference, otherwise a lambda will always return a copy.
auto func = [&](ValueType<Derived>& a) -> decltype(auto) { return a.*ptr; };
return has_value() ? FunctorMap(func, *derived()) : unexpected();
}
template <class R, class U>
constexpr FlattenExpected<const R&, E> map(R U::* ptr) const& {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
auto func = [&](const ValueType<Derived>& a) -> decltype(auto) { return a.*ptr; };
return has_value() ? FunctorMap(func, *derived()) : unexpected();
}
template <class R, class U>
constexpr FlattenExpected<Decay_t<R>, E> map(R U::* ptr) && {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
// NOTE: there is a subtle distinction here. If we want to get access to a member variable
// from an rvalue context, we MUST make a copy, since we cannot guarantee the reference will
// still be valid after destruction of the temporary.
auto func = [&](ValueType<Derived>&& a) { return a.*ptr; };
return has_value() ? FunctorMap(func, std::move(*derived())) : unexpected();
}
template <class R, class U>
constexpr FlattenExpected<Decay_t<R>, E> map(R U::* ptr) const&& {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
auto func = [&](const ValueType<Derived>&& a) { return a.*ptr; };
return has_value() ? FunctorMap(func, std::move(*derived())) : unexpected();
}
///-----------------------------------------------------------------------------------------------
/// Member Function Map
///-----------------------------------------------------------------------------------------------
template <class R, class U, class... Args>
constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...), Args&&... args) {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
auto func = [&](U& a) { return (a.*ptr)(std::forward<Args>(args)...); };
return has_value() ? FunctorMap(func, *derived()) : unexpected();
}
template <class R, class U, class... Args>
constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) & , Args&&... args) & {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
auto func = [&](U& a) { return (a.*ptr)(std::forward<Args>(args)...); };
return has_value() ? FunctorMap(func, *derived()) : unexpected();
}
template <class R, class U, class... Args>
constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) &&, Args&&... args) && {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
auto func = [&](U&& a) { return (std::move(a).*ptr)(std::forward<Args>(args)...); };
return has_value() ? FunctorMap(func, std::move(*derived())) : unexpected();
}
template <class R, class U, class... Args>
constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) const, Args&&... args) const {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
auto func = [&](const U& a) { return (a.*ptr)(std::forward<Args>(args)...); };
return has_value() ? FunctorMap(func, *derived()) : unexpected();
}
template <class R, class U, class... Args>
constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) const&, Args&&... args) const& {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
auto func = [&](const U& a) { return (a.*ptr)(std::forward<Args>(args)...); };
return has_value() ? FunctorMap(func, *derived()) : unexpected();
}
template <class R, class U, class... Args>
constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) const&&, Args&&... args) const&& {
static_assert(IsSame_v<U, RemoveCVRef_t<ValueType<Derived>>>,
"received pointer-to-member that is not of type T.");
auto func = [&](const U&& a) { return (std::move(a).*ptr)(std::forward<Args>(args)...); };
return has_value() ? FunctorMap(func, std::move(*derived())) : unexpected();
}
///-----------------------------------------------------------------------------------------------
/// Assign Value
///-----------------------------------------------------------------------------------------------
// Assigns the value of an expected directly to a concrete instance with perfect forwarding.
template <class U>
constexpr Expected<void, E> assign_to(U& value) const& {
static_assert(IsAssignable_v<U&, const ValueType<Derived>&>,
"Argument Type is not assignable with Expected Type (const T&)");
auto assign = [&](const ValueType<Derived>& derived) { value = derived; };
return has_value() ? FunctorMap(assign, *derived()) : unexpected();
}
template <class U>
constexpr Expected<void, E> assign_to(U& value) && {
static_assert(IsAssignable_v<U&, ValueType<Derived>&&>,
"Argument Type is not assignable with Expected Type (T&&)");
auto move_assign = [&](ValueType<Derived>&& derived) { value = std::move(derived); };
return has_value() ? FunctorMap(move_assign, std::move(*derived())) : std::move(unexpected());
}
///-----------------------------------------------------------------------------------------------
/// Guard
///-----------------------------------------------------------------------------------------------
template <class P>
constexpr Expected<ValueType<Derived>, E> guard(P&& pred, E&& new_error) const& {
if (is_error_) { return unexpected(); }
return pred(derived()->value()) ? *derived() : Unexpected<E>{new_error};
}
template <class P>
constexpr Expected<ValueType<Derived>, E> guard(P&& pred, E&& new_error) && {
if (is_error_) { return std::move(unexpected()); }
return pred(derived()->value()) ? std::move(*derived()) : Unexpected<E>{new_error};
}
///-----------------------------------------------------------------------------------------------
/// Ignore Error
///-----------------------------------------------------------------------------------------------
template <class U>
constexpr Expected<ValueType<Derived>, E> ignore_error(U&& next) const& {
return has_value() ? *derived() : std::forward<U>(next);
}
template <class U>
constexpr Expected<ValueType<Derived>, E> ignore_error(U&& next) && {
return has_value() ? std::move(*derived()) : std::forward<U>(next);
}
constexpr Expected<void, E> ignore_error() const { return {}; }
protected:
// Allow other Expected classes access to `unexpected` getters.
template <class, class, class>
friend class ExpectedBase;
// Protected default constructor so derived types can write custom initializers.
ExpectedBase() = default;
// Protected Value constructor so Derived types can convert to stored types
template <class... Args, EnableIf_t<IsConstructible_v<T, Args...>, void*> = nullptr>
constexpr ExpectedBase(Args&&... args) {
constructValueFrom(std::forward<Args>(args)...);
}
// Unexpected accessors to skip extra construction calls when not needed.
constexpr const Unexpected<E>& unexpected() const& {
GXF_ASSERT(is_error_, "Expected does not have an error. Check before accessing.");
return *ValuePointer<Unexpected<E>>(buffer_);
}
constexpr Unexpected<E>& unexpected() & {
GXF_ASSERT(is_error_, "Expected does not have an error. Check before accessing.");
return *ValuePointer<Unexpected<E>>(buffer_);
}
constexpr Unexpected<E>&& unexpected() && {
GXF_ASSERT(is_error_, "Expected does not have an error. Check before accessing.");
return std::move(*ValuePointer<Unexpected<E>>(buffer_));
}
// Returns a pointer to the derived type for accessing value result in supported specializations.
constexpr const Derived* derived() const { return static_cast<const Derived*>(this); }
constexpr Derived* derived() { return static_cast<Derived*>(this); }
///-----------------------------------------------------------------------------------------------
/// Construction Helpers
///-----------------------------------------------------------------------------------------------
// Construct a new object in allocated buffer.
template <class U, class G, class D>
constexpr void constructFrom(const ExpectedBase<U, G, D>& other) {
other.has_value() ? constructValueFrom(other) : constructErrorFrom(other);
}
// Move construct a new object in allocated buffer.
template <class U, class G, class D>
constexpr void constructFrom(ExpectedBase<U, G, D>&& other) {
other.has_value() ? constructValueFrom(std::move(other)) : constructErrorFrom(std::move(other));
}
template <class U, class G, class D>
constexpr void constructErrorFrom(const ExpectedBase<U, G, D>& other) {
is_error_ = true;
InplaceCopyConstruct(buffer_, *ValuePointer<Unexpected<G>>(other.buffer_));
}
template <class U, class G, class D>
constexpr void constructErrorFrom(ExpectedBase<U, G, D>&& other) {
is_error_ = true;
InplaceMoveConstruct(buffer_, std::move(*ValuePointer<Unexpected<G>>(other.buffer_)));
}
template <class U, class G, class D>
constexpr void constructValueFrom(const ExpectedBase<U, G, D>& other) {
is_error_ = false;
InplaceCopyConstruct<T>(buffer_, *ValuePointer<U>(other.buffer_));
}
template <class U, class G, class D>
constexpr void constructValueFrom(ExpectedBase<U, G, D>&& other) {
is_error_ = false;
InplaceConstruct<T>(buffer_, std::move(*ValuePointer<U>(other.buffer_)));
}
template <class... Args>
void constructValueFrom(Args&&... args) {
is_error_ = false;
InplaceConstruct<T>(buffer_, std::forward<Args>(args)...);
}
// Call the destructor for the current object explicitly
constexpr void destruct() {
has_value() ? Destruct<T>(buffer_) : Destruct<Unexpected<E>>(buffer_);
}
bool is_error_ = true;
const char* error_message_{};
static constexpr uint32_t kAlign =
(alignof(Unexpected<E>) < alignof(T)) ? alignof(T) : alignof(Unexpected<E>);
static constexpr uint32_t kSize =
(sizeof(Unexpected<E>) < sizeof(T)) ? sizeof(T) : sizeof(Unexpected<E>);
alignas(kAlign) byte buffer_[kSize] = {0};
};
} // namespace detail
///-------------------------------------------------------------------------------------------------
// Expected Implementation
///-------------------------------------------------------------------------------------------------
// Default instance for Expected types.
template <class T, class E>
class Expected : public detail::ExpectedBase<T, E, Expected<T, E>> {
public:
using detail::ExpectedBase<T, E, Expected>::ExpectedBase;
// Enable implicit construction of Move-Only types
constexpr Expected(T&& value) : detail::ExpectedBase<T, E, Expected>(std::move(value)) {}
template <class U, EnableIf_t<IsConstructible_v<T, U> && IsConvertible_v<U, T>>* = nullptr>
constexpr Expected(U&& value) : detail::ExpectedBase<T, E, Expected>(std::forward<U>(value)) {}
template <class U, EnableIf_t<IsConstructible_v<T, U> && !IsConvertible_v<U, T>>* = nullptr>
explicit constexpr Expected(U&& value)
: detail::ExpectedBase<T, E, Expected>(std::forward<U>(value)) {}
template <class... Args, EnableIf_t<IsConstructible_v<T, Args...>, void*> = nullptr>
explicit constexpr Expected(Args&&... args)
: detail::ExpectedBase<T, E, Expected>(std::forward<Args>(args)...) {}
template <class U, EnableIf_t<IsConstructible_v<T, U> && IsConvertible_v<U, T>>* = nullptr>
constexpr Expected(const Expected<U, E>& other) {
other.has_value() ? this->constructValueFrom(other.value()) : this->constructErrorFrom(other);
}
template <class U, EnableIf_t<IsConstructible_v<T, U> && !IsConvertible_v<U, T>>* = nullptr>
explicit constexpr Expected(const Expected<U, E>& other) {
other.has_value() ? this->constructValueFrom(other.value()) : this->constructErrorFrom(other);
}
template <class U, EnableIf_t<IsConstructible_v<T, U> && IsConvertible_v<U, T>>* = nullptr>
constexpr Expected(Expected<U, E>&& other) {
other.has_value() ? this->constructValueFrom(std::move(other.value()))
: this->constructErrorFrom(std::move(other));
}
template <class U, EnableIf_t<IsConstructible_v<T, U> && !IsConvertible_v<U, T>>* = nullptr>
explicit constexpr Expected(Expected<U, E>&& other) {
other.has_value() ? this->constructValueFrom(std::move(other.value()))
: this->constructErrorFrom(std::move(other));
}
template <class U = T, EnableIf_t<IsConstructible_v<T, U> && IsConvertible_v<U, T>>* = nullptr>
constexpr Expected& operator=(U&& value) {
this->destruct();
this->constructValueFrom(std::forward<U>(value));
return *this;
}
template <class... Args>
T& replace(Args&&... args) {
static_assert(IsConstructible_v<T, Args...>,
"T cannot be constructed with the provide argument types.");
this->destruct();
this->constructValueFrom(std::forward<Args>(args)...);
return value();
}
constexpr const T& value() const& {
GXF_ASSERT(this->has_value(), "Expected does not have a value. Check before accessing.");
return *ValuePointer<T>(this->buffer_);
}
constexpr T& value() & {
GXF_ASSERT(this->has_value(), "Expected does not have a value. Check before accessing.");
return *ValuePointer<T>(this->buffer_);
}
constexpr const T&& value() const&& {
GXF_ASSERT(this->has_value(), "Expected does not have a value. Check before accessing.");
return std::move(*ValuePointer<T>(this->buffer_));
}
constexpr T&& value() && {
GXF_ASSERT(this->has_value(), "Expected does not have a value. Check before accessing.");
return std::move(*ValuePointer<T>(this->buffer_));
}
};
///-------------------------------------------------------------------------------------------------
/// Expected of Reference Implementation
///-------------------------------------------------------------------------------------------------
// Specialization of Expected for references.
template <class T, class E>
class Expected<T&, E> : public detail::ExpectedBase<T*, E, Expected<T&, E>> {
private:
template <class, class = void>
struct IsExpectedConvertible : FalseType {};
template <class U>
struct IsExpectedConvertible<U, void_t<decltype(Declval<U>().value())>>
: IsConvertible<decltype(Declval<U>().value()), T&> {};
template <class U>
static constexpr bool IsExpectedConvertible_v =
detail::IsExpected_v<U> && IsExpectedConvertible<U>::value;
public:
using detail::ExpectedBase<T*, E, Expected>::ExpectedBase;
template <class U, EnableIf_t<IsConvertible_v<U, T&>, void*> = nullptr>
constexpr Expected(U&& value) : detail::ExpectedBase<T*, E, Expected>(&std::forward<U>(value)) {}
template <class U, EnableIf_t<IsExpectedConvertible_v<U>, void*> = nullptr>
constexpr Expected(U&& other) {
other.has_value() ? this->constructValueFrom(&std::forward<U>(other).value())
: this->constructErrorFrom(std::forward<U>(other));
}
constexpr T& value() const {
GXF_ASSERT(this->has_value(), "Expected does not have a value. Check before accessing.");
return **ValuePointer<T*>(this->buffer_);
}
};
///-------------------------------------------------------------------------------------------------
/// Expected of Void Implementation
///-------------------------------------------------------------------------------------------------
// Specialization of Expected for void. This is essentially an std::optional<E>.
template <class E>
class Expected<void, E> : public detail::ExpectedBase<detail::Unit, E, Expected<void, E>> {
public:
using detail::ExpectedBase<detail::Unit, E, Expected>::ExpectedBase;
constexpr Expected() : detail::ExpectedBase<detail::Unit, E, Expected>(detail::Unit{}) {}
// Constructor that allows assigning an Expected with the same error type to an Expected<void>
template <class U>
explicit constexpr Expected(const Expected<U, E>& other) {
other.has_value() ? this->constructValueFrom() : this->constructErrorFrom(other);
}
// Constructor that allows assigning an Expected with the same error type to an Expected<void>
template <class U>
explicit constexpr Expected(Expected<U, E>&& other) {
other.has_value() ? this->constructValueFrom() : this->constructErrorFrom(std::move(other));
}
// Combines two expected value taking the first error.
template <class U>
Expected& operator&=(const Expected<U, E>& other) {
*this = *this & other;
return *this;
}
// Combines two expected value taking the last success.
template <class U>
Expected& operator|=(const Expected<U, E>& other) {
*this = *this | other;
return *this;
}
};
///-------------------------------------------------------------------------------------------------
/// Utility Functions
///-------------------------------------------------------------------------------------------------
// Checks if all Expected values are not in error. If in error, return the first error found.
template <class E, class T>
Expected<void, E> AllOf(const Expected<T, E>& expected) {
return Expected<void, E>{expected};
}
// Checks if all Expected values are not in error. If in error, return the first error found.
template <class E, class T, class... Ts>
Expected<void, E> AllOf(const Expected<T, E>& expected, const Expected<Ts, E>&... others) {
return expected & AllOf(others...);
}
// Checks if all the Arguments are of type Expected<T, E>. If so, unwraps them and calls
// the function object F with the unwrapped arguments. Otherwise, return an Unexpected with
// the first error value found in the argument list.
template <class F, class... Args>
auto Apply(F&& func, Args&&... args) -> EnableIf_t<
Conjunction_v<detail::IsExpected<Args>...>, decltype(detail::FunctorMap(func, args...)) > {
const auto all_valid = AllOf(std::forward<Args>(args)...);
if (!all_valid) { return Unexpected<detail::ErrorType<Args...>>(all_valid.error()); }
return detail::FunctorMap(std::forward<F>(func), std::forward<Args>(args)...);
}
///-------------------------------------------------------------------------------------------------
/// Comparison Operators
///-------------------------------------------------------------------------------------------------
template <class T, class E, class U, class G>
constexpr bool operator==(const Expected<T, E>& lhs, const Expected<U, G>& rhs) {
return ( lhs && rhs && (lhs.value() == rhs.value())) ||
(!lhs && !rhs && (lhs.error() == rhs.error()));
}
template <class T, class E, class U>
constexpr bool operator==(const Expected<T, E>& lhs, const U& rhs) {
return lhs && (*lhs == rhs);
}
template <class T, class E, class U>
constexpr bool operator==(const U& lhs, const Expected<T, E>& rhs) {
return rhs && (lhs == *rhs);
}
template <class T, class E>
constexpr bool operator==(const Expected<T, E>& lhs, const Unexpected<E>& rhs) {
return !lhs && (lhs.error() == rhs.value());
}
template <class T, class E>
constexpr bool operator==(const Unexpected<E>& lhs, const Expected<T, E>& rhs) {
return !rhs && (lhs.value() == rhs.error());
}
template <class E>
constexpr bool operator==(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {
return lhs.value() == rhs.value();
}
// All inequality operators are defined in terms of negated equality
template <class T, class E, class U, class G>
constexpr bool operator!=(const Expected<T, E>& lhs, const Expected<U, G>& rhs) {
return !(lhs == rhs);
}
template <class T, class E, class U>
constexpr bool operator!=(const Expected<T, E>& lhs, const U& rhs) {
return !(lhs == rhs);
}
template <class T, class E, class U>
constexpr bool operator!=(const U& lhs, const Expected<T, E>& rhs) {
return !(lhs == rhs);
}
template <class E>
constexpr bool operator!=(const Unexpected<E>& lhs, const Unexpected<E>& rhs) {
return !(lhs == rhs);
}
///-------------------------------------------------------------------------------------------------
/// Binary Logical Operators
///-------------------------------------------------------------------------------------------------
// Combines two expected value taking the first error.
template <class E, class T, class U>
Expected<void, E> operator&(const Expected<T, E>& lhs, const Expected<U, E>& rhs) {
return !lhs ? Expected<void, E>{lhs} : Expected<void, E>{rhs};
}
// Combines two expected value taking the last success.
template <class E, class T, class U>
Expected<void, E> operator|(const Expected<T, E>& lhs, const Expected<U, E>& rhs) {
return rhs ? Expected<void, E>{rhs} : Expected<void, E>{lhs};
}
///-------------------------------------------------------------------------------------------------
/// Binary Arithmetic Operators
///-------------------------------------------------------------------------------------------------
// Arithmetic operator+ for values stored in expected values. Returns either the computed value
// or the first unexpected among lhs and rhs.
template <class V, class E>
Expected<V, E> operator+(const Expected<V, E>& lhs, const Expected<V, E>& rhs) {
return Apply([](const V& lhs, const V& rhs) { return lhs + rhs; }, lhs, rhs);
}
template <class V, class E>
Expected<V, E> operator+(const Expected<V, E>& lhs, const V& rhs) {
return lhs.map([&](const V& value) { return value + rhs; });
}
template <class V, class E>
Expected<V, E> operator+(const V& lhs, const Expected<V, E>& rhs) {
return rhs.map([&](const V& value) { return lhs + value; });
}
// Arithmetic operator- for values stored in expected values. Returns either the computed value
// or the first unexpected among lhs and rhs.
template <class V, class E>
Expected<V, E> operator-(const Expected<V, E>& lhs, const Expected<V, E>& rhs) {
return Apply([](const V& lhs, const V& rhs) { return lhs - rhs; }, lhs, rhs);
}
template <class V, class E>
Expected<V, E> operator-(const Expected<V, E>& lhs, const V& rhs) {
return lhs.map([&](const V& value) { return value - rhs; });
}
template <class V, class E>
Expected<V, E> operator-(const V& lhs, const Expected<V, E>& rhs) {
return rhs.map([&](const V& value) { return lhs - value; });
}
// Arithmetic operator* for values stored in expected values. Returns either the computed value
// or the first unexpected among lhs and rhs.
template <class V, class E>
Expected<V, E> operator*(const Expected<V, E>& lhs, const Expected<V, E>& rhs) {
return Apply([](const V& lhs, const V& rhs) { return lhs * rhs; }, lhs, rhs);
}
template <class V, class E>
Expected<V, E> operator*(const Expected<V, E>& lhs, const V& rhs) {
return lhs.map([&](const V& value) { return value * rhs; });
}
template <class V, class E>
Expected<V, E> operator*(const V& lhs, const Expected<V, E>& rhs) {
return rhs.map([&](const V& value) { return lhs * value; });
}
// Arithmetic operator/ for values stored in expected values. Returns either the computed value
// or the first unexpected among lhs and rhs.
template <class V, class E>
Expected<V, E> operator/(const Expected<V, E>& lhs, const Expected<V, E>& rhs) {
return Apply([](const V& lhs, const V& rhs) { return lhs / rhs; }, lhs, rhs);
}
template <class V, class E>
Expected<V, E> operator/(const Expected<V, E>& lhs, const V& rhs) {
return lhs.map([&](const V& value) { return value / rhs; });
}
template <class V, class E>
Expected<V, E> operator/(const V& lhs, const Expected<V, E>& rhs) {
return rhs.map([&](const V& value) { return lhs / value; });
}
// Arithmetic operator% for values stored in expected values. Returns either the computed value
// or the first unexpected among lhs and rhs.
template <class V, class E>
Expected<V, E> operator%(const Expected<V, E>& lhs, const Expected<V, E>& rhs) {
return Apply([](const V& lhs, const V& rhs) { return lhs % rhs; }, lhs, rhs);
}
template <class V, class E>
Expected<V, E> operator%(const Expected<V, E>& lhs, const V& rhs) {
return lhs.map([&](const V& value) { return value % rhs; });
}
template <class V, class E>
Expected<V, E> operator%(const V& lhs, const Expected<V, E>& rhs) {
return rhs.map([&](const V& value) { return lhs % value; });
}
} // namespace nvidia
#endif // NVIDIA_COMMON_EXPECTED_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/fixed_map.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_GXF_COMMON_FIXED_MAP_HPP_
#define NVIDIA_GXF_COMMON_FIXED_MAP_HPP_
#include <iterator>
#include <utility>
#include "common/expected.hpp"
#include "common/memory_utils.hpp"
#include "common/type_utils.hpp"
namespace nvidia {
// Data structure that provides similar functionality to std::unordered_map but does not dynamically
// reallocate memory and uses Expected type for error handling instead of exceptions.
// This container is not thread-safe.
template <typename Key, typename T, typename Hash = std::hash<Key>>
class FixedMap {
public:
template <typename TContainer, typename TValue = typename TContainer::value_type>
class Iterator;
template <typename TIterator>
class ReverseIterator;
template <typename TContainer>
using ConstIterator = Iterator<const TContainer, const typename TContainer::value_type>;
// Use STL naming convention for compatibility with STL algorithms
using key_type = Key;
using mapped_type = T;
using value_type = std::pair<const key_type, mapped_type>;
using size_type = size_t;
using iterator = Iterator<FixedMap>;
using reverse_iterator = ReverseIterator<iterator>;
using const_iterator = ConstIterator<FixedMap>;
using const_reverse_iterator = ReverseIterator<const_iterator>;
// Custom error codes for map
enum struct Error {
kOutOfMemory, // Memory allocation failed
kInvalidKey, // Key is not in container
kDuplicateKey, // Key is already in container
kContainerFull, // Container is full
kInvalidIterator, // Iterator is invalid
};
// Expected type which uses class specific errors
template <typename U>
using Expected = Expected<U, Error>;
template <typename TContainer, typename TValue>
class Iterator {
public:
static_assert(IsSame_v<RemoveConst_t<TContainer>, FixedMap>);
// iterator traits
using iterator_category = std::bidirectional_iterator_tag;
using value_type = TValue;
using difference_type = std::ptrdiff_t;
using pointer = TValue*;
using reference = TValue&;
constexpr Iterator() : container_{nullptr}, index_{-1} {}
constexpr Iterator(TContainer& container, size_t start) : container_{&container}, index_{0} {
*this += start;
}
constexpr Iterator(const Iterator& other) = default;
constexpr Iterator(Iterator&& other) = default;
constexpr Iterator& operator=(const Iterator& other) = default;
constexpr Iterator& operator=(Iterator&& other) = default;
constexpr Expected<TValue&> operator*() const {
if (container_ == nullptr || container_->data_ == nullptr ||
index_ < 0 || index_ >= static_cast<difference_type>(container_->capacity_)) {
return Unexpected<Error>{Error::kInvalidIterator};
}
Bucket& bucket = container_->data_[index_];
if (!bucket.occupied) {
return Unexpected<Error>{Error::kInvalidIterator};
}
return bucket.value;
}
constexpr Iterator& operator+=(difference_type offset) {
if (container_ == nullptr || container_->data_ == nullptr) {
return *this;
}
while (true) {
const Bucket& bucket = container_->data_[index_];
if (bucket.occupied) {
break;
}
index_++;
if (index_ >= static_cast<difference_type>(container_->capacity_)) {
break;
}
}
if ((offset > 0 && index_ >= static_cast<difference_type>(container_->capacity_)) ||
(offset < 0 && index_ <= 0)) {
return *this;
}
while (offset > 0) {
index_++;
if (index_ >= static_cast<difference_type>(container_->capacity_)) {
break;
}
const Bucket& bucket = container_->data_[index_];
if (bucket.occupied) {
offset--;
}
}
while (offset < 0) {
index_--;
if (index_ <= 0) {
break;
}
const Bucket& bucket = container_->data_[index_];
if (bucket.occupied) {
offset++;
}
}
return *this;
}
constexpr Iterator& operator++() {
*this += 1;
return *this;
}
constexpr Iterator operator++(int) {
Iterator iter = *this;
++(*this);
return iter;
}
constexpr Iterator& operator-=(difference_type offset) {
*this += -offset;
return *this;
}
constexpr Iterator& operator--() {
*this -= 1;
return *this;
}
constexpr Iterator operator--(int) {
Iterator iter = *this;
--(*this);
return iter;
}
friend constexpr Iterator operator+(Iterator a, difference_type n) {
a += n;
return a;
}
friend constexpr Iterator operator+(difference_type n, Iterator a) {
return a + n;
}
friend constexpr Iterator operator-(Iterator a, difference_type n) {
a -= n;
return a;
}
friend constexpr difference_type operator-(const Iterator& a, const Iterator& b) {
return a.index_ - b.index_;
}
friend constexpr bool operator==(const Iterator& a, const Iterator& b) {
return a.container_ == b.container_ && a.index_ == b.index_;
}
friend constexpr bool operator!=(const Iterator& a, const Iterator& b) {
return !(a == b);
}
private:
// Container pointer
TContainer* container_;
// Iterator index
difference_type index_;
};
template <typename TIterator>
class ReverseIterator {
public:
static_assert(IsSame_v<TIterator, iterator> || IsSame_v<TIterator, const_iterator>);
using TValue = typename TIterator::value_type;
// iterator traits
using iterator_category = std::bidirectional_iterator_tag;
using value_type = TValue;
using difference_type = std::ptrdiff_t;
using pointer = TValue*;
using reference = TValue&;
constexpr explicit ReverseIterator() : iter_{} {}
constexpr explicit ReverseIterator(TIterator iter) : iter_{iter} {}
constexpr ReverseIterator(const ReverseIterator& other) = default;
constexpr ReverseIterator(ReverseIterator&& other) = default;
constexpr ReverseIterator& operator=(const ReverseIterator& other) = default;
constexpr ReverseIterator& operator=(ReverseIterator&& other) = default;
constexpr TIterator base() const { return iter_; }
constexpr Expected<TValue&> operator*() const { return *std::prev(iter_); }
constexpr ReverseIterator& operator+=(difference_type offset) {
iter_ -= offset;
return *this;
}
constexpr ReverseIterator& operator++() {
iter_ -= 1;
return *this;
}
constexpr ReverseIterator operator++(int) {
ReverseIterator iter = *this;
++(*this);
return iter;
}
constexpr ReverseIterator& operator-=(difference_type offset) {
iter_ += offset;
return *this;
}
constexpr ReverseIterator& operator--() {
iter_ += 1;
return *this;
}
constexpr ReverseIterator operator--(int) {
ReverseIterator iter = *this;
--(*this);
return iter;
}
friend constexpr ReverseIterator operator+(ReverseIterator a, difference_type n) {
return ReverseIterator(a.iter_ - n);
}
friend constexpr ReverseIterator operator+(difference_type n, ReverseIterator a) {
return ReverseIterator(a.iter_ - n);
}
friend constexpr ReverseIterator operator-(ReverseIterator a, difference_type n) {
return ReverseIterator(a.iter_ + n);
}
friend constexpr difference_type operator-(const ReverseIterator& a, const ReverseIterator& b) {
return b.iter_ - a.iter_;
}
friend constexpr bool operator==(const ReverseIterator& a, const ReverseIterator& b) {
return a.iter_ == b.iter_;
}
friend constexpr bool operator!=(const ReverseIterator& a, const ReverseIterator& b) {
return !(a == b);
}
private:
/// Random-access iterator
TIterator iter_;
};
FixedMap() : data_{nullptr}, capacity_{0}, size_{0} {}
FixedMap(const FixedMap& other) = delete;
FixedMap(FixedMap&& other) : data_{nullptr}, capacity_{0}, size_{0} { *this = std::move(other); }
FixedMap& operator=(const FixedMap& other) = delete;
FixedMap& operator=(FixedMap&& other) {
if (this != &other) {
std::swap(data_, other.data_);
std::swap(capacity_, other.capacity_);
std::swap(size_, other.size_);
}
return *this;
}
~FixedMap() {
clear();
DeallocateArray<Bucket>(data_);
}
bool operator==(const FixedMap& other) const {
if ((capacity_ != other.capacity_) || (size_ != other.size_)) {
return false;
}
for (size_type i = 0; i < capacity_; i++) {
if (data_[i].occupied) {
if (!other.data_[i].occupied || (data_[i].value != other.data_[i].value)) {
return false;
}
}
}
return true;
}
bool operator!=(const FixedMap& other) const { return !(*this == other); }
constexpr iterator begin() { return iterator(*this, 0); }
constexpr iterator end() { return iterator(*this, size_); }
constexpr reverse_iterator rbegin() { return reverse_iterator(end()); }
constexpr reverse_iterator rend() { return reverse_iterator(begin()); }
constexpr const_iterator begin() const { return cbegin(); }
constexpr const_iterator end() const { return cend(); }
constexpr const_reverse_iterator rbegin() const { return crbegin(); }
constexpr const_reverse_iterator rend() const { return crend(); }
constexpr const_iterator cbegin() const { return const_iterator(*this, 0); }
constexpr const_iterator cend() const { return const_iterator(*this, size_); }
constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
constexpr const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
Expected<mapped_type&> operator[](const key_type& key) {
Bucket* bucket = findMatchingBucket(key);
if (!bucket) {
auto result = emplace(std::make_pair(key, mapped_type()));
if (!result) {
return Unexpected<Error>{result.error()};
}
bucket = findMatchingBucket(key);
if (!bucket) {
return Unexpected<Error>{Error::kInvalidKey};
}
}
return bucket->value.second;
}
// Returns the number of elements the container can currently hold
size_type capacity() const { return capacity_; }
// Returns the number of elements in the container
size_type size() const { return size_; }
// Returns true if the container has no elements
bool empty() const { return size_ == 0; }
// Returns true if the container has reached capacity
bool full() const { return size_ == capacity_; }
// Returns the load factor of the container
double load_factor() const {
return capacity_ > 0 ? static_cast<double>(size_) / static_cast<double>(capacity_) : 0.0;
}
// Checks if the container has a value for the given key
bool contains(const key_type& key) const { return findMatchingBucket(key) != nullptr; }
// Returns a reference to the value at the given key
Expected<mapped_type&> at(const key_type& key) {
Bucket* bucket = findMatchingBucket(key);
if (!bucket) {
return Unexpected<Error>{Error::kInvalidKey};
}
return bucket->value.second;
}
// Returns a read-only reference to the value with the given key
Expected<const mapped_type&> at(const key_type& key) const {
Bucket* bucket = findMatchingBucket(key);
if (!bucket) {
return Unexpected<Error>{Error::kInvalidKey};
}
return bucket->value.second;
}
// Update a key that is already in the map
Expected<void> update(const key_type& key, const mapped_type& value) {
Bucket* bucket = findMatchingBucket(key);
if (!bucket) { return Unexpected<Error>{Error::kInvalidKey}; }
bucket->value.second = value;
return kSuccess;
}
// Assigns an the value to the given key if it exists, else creates a new object
template <typename... Args>
Expected<void> insert_or_assign(Args&&... args) {
value_type value(std::forward<Args>(args)...);
Bucket* bucket = findMatchingBucket(value.first);
if (bucket) {
bucket->value.second = value.second;
return kSuccess;
} else {
return emplace(std::move(value));
}
}
// Creates a new object with the provided arguments and adds it using the given key
template <typename... Args>
Expected<void> emplace(Args&&... args) {
value_type value(std::forward<Args>(args)...);
if (findMatchingBucket(value.first)) {
return Unexpected<Error>{Error::kDuplicateKey};
}
Bucket* bucket = findEmptyBucket(value.first);
if (!bucket) {
return Unexpected<Error>{Error::kContainerFull};
}
InplaceMoveConstruct<value_type>(BytePointer(&bucket->value), std::move(value));
bucket->occupied = true;
size_++;
return kSuccess;
}
// Copies the object with the given key
Expected<void> insert(const value_type& value) { return emplace(value); }
// Moves the object with the given key
Expected<void> insert(value_type&& value) {
return emplace(std::forward<value_type>(value));
}
// Removes the object at the given key and destroys it
Expected<void> erase(const key_type& key) {
Bucket* bucket = findMatchingBucket(key);
if (!bucket) {
return Unexpected<Error>{Error::kInvalidKey};
}
Destruct<value_type>(BytePointer(&bucket->value));
bucket->occupied = false;
size_--;
return kSuccess;
}
// Removes all objects from the vector
void clear() {
for (size_type i = 0; i < capacity_; i++) {
Bucket* bucket = &data_[i];
if (bucket->occupied) {
Destruct<value_type>(BytePointer(&bucket->value));
bucket->occupied = false;
}
}
size_ = 0;
}
// Allocates memory to hold the specified number of elements
Expected<void> reserve(size_type capacity) {
if (capacity > capacity_) {
Bucket* const temp_data = data_;
const size_type temp_capacity = capacity_;
const size_type temp_size = size_;
data_ = AllocateArray<Bucket>(capacity);
capacity_ = capacity;
size_ = 0;
if (data_ == nullptr) {
data_ = temp_data;
capacity_ = temp_capacity;
size_ = temp_size;
return Unexpected<Error>{Error::kOutOfMemory};
}
for (size_type i = 0; i < capacity_; i++) {
data_[i].occupied = false;
}
for (size_type i = 0; i < temp_capacity; i++) {
Bucket* bucket = &temp_data[i];
if (bucket->occupied) {
auto result = emplace(std::move(bucket->value));
if (!result) {
return Unexpected<Error>{result.error()};
}
}
}
DeallocateArray<Bucket>(temp_data);
}
return kSuccess;
}
// Copies the contents of the given map
// Current contents are discarded
// Fails if given map is larger than current capacity
Expected<void> copy_from(const FixedMap& other) {
if (other.size_ > capacity_) {
return Unexpected<Error>{Error::kContainerFull};
}
clear();
for (size_type i = 0; i < other.capacity_; i++) {
Bucket* bucket = &other.data_[i];
if (bucket->occupied) {
auto result = emplace(bucket->value.first, bucket->value.second);
if (!result) {
return Unexpected<Error>{result.error()};
}
}
}
return kSuccess;
}
private:
// Container for a key-value pair
struct Bucket {
value_type value;
bool occupied;
};
// Searches for a matching bucket with the given key
Bucket* findMatchingBucket(const key_type& key) const {
if (capacity_ == 0) {
return nullptr;
}
size_type index = hash(key);
const size_type start = index;
Bucket* bucket = &data_[index];
// Look for a matching bucket
while (bucket->occupied) {
if (bucket->value.first == key) {
return bucket;
}
index = (index + 1) % capacity_;
bucket = &data_[index];
if (index == start) {
return nullptr;
}
}
return nullptr;
}
// Searches for an empty bucket with the given key
Bucket* findEmptyBucket(const key_type& key) const {
if (capacity_ == 0) {
return nullptr;
}
size_type index = hash(key);
const size_type start = index;
Bucket* bucket = &data_[index];
// Look for an empty bucket
while (bucket->occupied) {
index = (index + 1) % capacity_;
bucket = &data_[index];
if (index == start) {
return nullptr;
}
}
return bucket;
}
// Computes a hash of the given key that can be used as a table index
size_type hash(const key_type& key) const { return Hash{}(key) % capacity_; }
// Special value for returning a success
const Expected<void> kSuccess{};
// Pointer to an array of entries
Bucket* data_;
// Maximum number of entries the container can hold
size_type capacity_;
// Number of entries stored
size_type size_;
};
} // namespace nvidia
#endif // NVIDIA_GXF_COMMON_FIXED_MAP_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/fixed_string.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_GXF_COMMON_FIXED_STRING_HPP_
#define NVIDIA_GXF_COMMON_FIXED_STRING_HPP_
#include <algorithm>
#include <cstring>
#include "common/expected.hpp"
#include "common/iterator.hpp"
#include "common/type_utils.hpp"
namespace nvidia {
// Safety container that substitutes std::string and uses Expected for error handling.
// Uses a fixed-size buffer allocated on the stack for storage.
template <size_t N>
class FixedString {
public:
// Use STL naming convention for compatibility with STL algorithms
using value_type = char;
using size_type = size_t;
using const_iterator = ConstRandomAccessIterator<FixedString>;
using const_reverse_iterator = ReverseIterator<const_iterator>;
// Hash support
struct Hash {
template <size_t M>
size_t operator()(const FixedString<M>& str) const {
return std::_Hash_impl::hash(str.data(), str.size());
}
};
// Custom error codes for container
enum struct Error {
kArgumentNull,
kExceedingPreallocatedSize,
};
// Expected type which uses class specific errors
template <typename U>
using Expected = Expected<U, Error>;
// Constructors
constexpr FixedString() { clear(); }
template <size_t M>
constexpr FixedString(const char (&str)[M]) { copy(str); }
template <size_t M>
constexpr FixedString(const FixedString<M>& str) { copy(str); }
// Assignment operators
template <size_t M>
constexpr FixedString& operator=(const char (&other)[M]) {
copy(other);
return *this;
}
template <size_t M>
constexpr FixedString& operator=(const FixedString<M>& other) {
copy(other);
return *this;
}
// ISO standards state the assignment operator for M = N cannot be a template
constexpr FixedString& operator=(const FixedString& other) {
copy(other);
return *this;
}
constexpr const_iterator begin() const { return cbegin(); }
constexpr const_iterator end() const { return cend(); }
constexpr const_reverse_iterator rbegin() const { return crbegin(); }
constexpr const_reverse_iterator rend() const { return crend(); }
constexpr const_iterator cbegin() const { return const_iterator(*this, 0); }
constexpr const_iterator cend() const { return const_iterator(*this, size_); }
constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
constexpr const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
// Comparison operators
template <size_t M>
constexpr bool operator==(const char (&other)[M]) const { return compare(other) == 0; }
template <size_t M>
constexpr bool operator==(const FixedString<M>& other) const { return compare(other) == 0; }
template <size_t M>
constexpr bool operator!=(const char (&other)[M]) const { return !(*this == other); }
template <size_t M>
constexpr bool operator!=(const FixedString<M>& other) const { return !(*this == other); }
template <size_t M>
constexpr bool operator<(const char (&other)[M]) const { return compare(other) < 0; }
template <size_t M>
constexpr bool operator<(const FixedString<M>& other) const { return compare(other) < 0; }
template <size_t M>
constexpr bool operator<=(const char (&other)[M]) const { return compare(other) <= 0; }
template <size_t M>
constexpr bool operator<=(const FixedString<M>& other) const { return compare(other) <= 0; }
template <size_t M>
constexpr bool operator>(const char (&other)[M]) const { return !(*this <= other); }
template <size_t M>
constexpr bool operator>(const FixedString<M> other) const { return !(*this <= other); }
template <size_t M>
constexpr bool operator>=(const char (&other)[M]) const { return !(*this < other); }
template <size_t M>
constexpr bool operator>=(const FixedString<M> other) const { return !(*this < other); }
// Returns the length of the string excluding the null terminator
constexpr size_t size() const { return size_; }
constexpr size_t length() const { return size_; }
// Returns the number of characters the string can store excluding the null terminator
constexpr size_t max_size() const { return kMaxSize; }
// Returns the number of characters the string can store including the null terminator
constexpr size_t capacity() const { return kCapacity; }
// Returns true if the string is empty
constexpr bool empty() const { return size_ == 0; }
// Returns true if the string is full
constexpr bool full() const { return size_ == kMaxSize; }
// Returns a pointer to a null-terminated array of characters
constexpr AddLvalueReference_t<const char[N + 1]> data() const { return data_; }
constexpr AddLvalueReference_t<const char[N + 1]> c_str() const { return data_; }
// Clears the string
constexpr void clear() {
size_ = 0;
data_[size_] = '\0';
}
// Appends a C-string to the end of the string
constexpr Expected<void> append(const char* str, size_t size) {
if (str == nullptr) {
return Unexpected<Error>{Error::kArgumentNull};
}
const size_t length = strnlen(str, size);
if (size_ + length > kMaxSize) {
return Unexpected<Error>{Error::kExceedingPreallocatedSize};
}
std::memcpy(&data_[size_], str, length);
size_ += length;
data_[size_] = '\0';
return kSuccess;
}
// Appends a character array to the end of the string
template <size_t M>
constexpr Expected<void> append(const char (&str)[M]) { return append(str, M); }
// Appends a fixed string to the end of the string
template <size_t M>
constexpr Expected<void> append(const FixedString<M>& str) {
return append(str.data(), str.size());
}
// Appends a character to the end of the string
constexpr Expected<void> append(char c) { return append(&c, 1); }
// Copies a C-string to the string
constexpr Expected<void> copy(const char* str, size_t size) {
clear();
return append(str, size);
}
// Copies a character array to the string
template <size_t M>
constexpr void copy(const char (&str)[M]) {
static_assert(M <= kMaxSize, "Exceeding container capacity");
copy(str, M);
}
// Copies a fixed string to the string
template <size_t M>
constexpr void copy(const FixedString<M>& str) {
static_assert(M <= kMaxSize, "Exceeding container capacity");
copy(str.data(), str.size());
}
// Compares string to a character array
template <size_t M>
constexpr int compare(const char (&str)[M]) const {
const size_t length = strnlen(str, M);
const int result = std::strncmp(data_, str, std::min(size_, length));
if (result != 0) {
return result;
}
if (length > size_) {
return -1;
}
if (length < size_) {
return 1;
}
return 0;
}
// Compares string to a fixed string
template <size_t M>
constexpr int compare(const FixedString<M>& str) const { return compare(str.data()); }
private:
// Storage capacity
static constexpr size_t kCapacity = N + 1;
// Maximum length of the string
static constexpr size_t kMaxSize = N;
// Special value for returning a success
const Expected<void> kSuccess{};
// String length
size_t size_;
// Data buffer
char data_[kCapacity];
};
} // namespace nvidia
#endif // NVIDIA_GXF_COMMON_FIXED_STRING_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/fixed_vector.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_GXF_COMMON_FIXED_VECTOR_HPP_
#define NVIDIA_GXF_COMMON_FIXED_VECTOR_HPP_
#include <cstring>
#include <utility>
#include "common/byte.hpp"
#include "common/expected.hpp"
#include "common/iterator.hpp"
#include "common/memory_utils.hpp"
namespace nvidia {
// Data structure that provides similar functionality to std::vector but does not dynamically
// reallocate memory and uses Expected type for error handling instead of exceptions.
// This container is not thread-safe.
//
// This container supports allocating memory on the stack or on the heap. If the template argument
// N is specified and greater than 0, a container with a capacity of N will be created on the stack.
// The stack allocated container cannot be resized after it is initialized. The heap allocated
// container must use the reserve function to allocate memory before use. It does not support
// copy assignment or construction.
// Base implementation
template <typename T>
class FixedVectorBase {
public:
// Use STL naming convention for compatibility with STL algorithms
using value_type = T;
using size_type = size_t;
using iterator = RandomAccessIterator<FixedVectorBase>;
using reverse_iterator = ReverseIterator<iterator>;
using const_iterator = ConstRandomAccessIterator<FixedVectorBase>;
using const_reverse_iterator = ReverseIterator<const_iterator>;
virtual ~FixedVectorBase() = default;
// Custom error codes for vector
enum struct Error {
kOutOfMemory, // Memory allocation failed
kArgumentOutOfRange, // Argument is out of valid range
kContainerEmpty, // Container is empty
kContainerFull, // Container is fixed and reached max capacity
kInvalidIterator, // Iterator is invalid
};
// Expected type which uses class specific errors
template <typename U>
using Expected = Expected<U, Error>;
constexpr bool operator==(const FixedVectorBase& other) const {
if (size_ != other.size_) {
return false;
}
if (data_ == other.data_) {
return true;
}
for (size_t i = 0; i < size_; i ++) {
if (data_[i] != other.data_[i]) {
return false;
}
}
return true;
}
constexpr bool operator!=(const FixedVectorBase& other) const { return !(*this == other); }
constexpr iterator begin() { return iterator(*this, 0); }
constexpr iterator end() { return iterator(*this, size_); }
constexpr reverse_iterator rbegin() { return reverse_iterator(end()); }
constexpr reverse_iterator rend() { return reverse_iterator(begin()); }
constexpr const_iterator begin() const { return cbegin(); }
constexpr const_iterator end() const { return cend(); }
constexpr const_reverse_iterator rbegin() const { return crbegin(); }
constexpr const_reverse_iterator rend() const { return crend(); }
constexpr const_iterator cbegin() const { return const_iterator(*this, 0); }
constexpr const_iterator cend() const { return const_iterator(*this, size_); }
constexpr const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); }
constexpr const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); }
constexpr Expected<T&> operator[](size_t index) { return at(index); }
constexpr Expected<const T&> operator[](size_t index) const { return at(index); }
// Returns a pointer to data
constexpr T* data() { return data_; }
// Returns a read-only pointer to data
constexpr const T* data() const { return data_; }
// Returns the number of elements the vector can currently hold
constexpr size_t capacity() const { return capacity_; }
// Returns the number of elements in the vector
constexpr size_t size() const { return size_; }
// Returns true if the vector contains no elements
constexpr bool empty() const { return size_ == 0; }
// Returns true if the vector reached capacity
constexpr bool full() const { return size_ == capacity_; }
// Returns a reference to the element at the given index
constexpr Expected<T&> at(size_t index) {
if (index >= size_) {
return Unexpected<Error>{Error::kArgumentOutOfRange};
}
return data_[index];
}
// Returns a read-only reference to the element at the given index
constexpr Expected<const T&> at(size_t index) const {
if (index >= size_) {
return Unexpected<Error>{Error::kArgumentOutOfRange};
}
return data_[index];
}
// Returns a reference to the first element
constexpr Expected<T&> front() {
if (empty()) {
return Unexpected<Error>{Error::kContainerEmpty};
}
return data_[0];
}
// Returns a read-only reference to the first element
constexpr Expected<const T&> front() const {
if (empty()) {
return Unexpected<Error>{Error::kContainerEmpty};
}
return data_[0];
}
// Returns a reference to the last element
constexpr Expected<T&> back() {
if (empty()) {
return Unexpected<Error>{Error::kContainerEmpty};
}
return data_[size_ - 1];
}
// Returns a read-only reference to the last element
constexpr Expected<const T&> back() const {
if (empty()) {
return Unexpected<Error>{Error::kContainerEmpty};
}
return data_[size_ - 1];
}
// Creates a new object with the provided arguments and adds it at the specified index
template <typename... Args>
constexpr Expected<void> emplace(size_t index, Args&&... args) {
if (index > size_) {
return Unexpected<Error>{Error::kArgumentOutOfRange};
}
if (full()) {
return Unexpected<Error>{Error::kContainerFull};
}
if (index < size_) {
ArrayMoveConstruct(BytePointer(&data_[index + 1]), &data_[index], size_ - index);
}
InplaceConstruct<T>(BytePointer(&data_[index]), std::forward<Args>(args)...);
size_++;
return kSuccess;
}
// Creates a new object with the provided arguments and adds it to the end of the vector
template <typename... Args>
constexpr Expected<void> emplace_back(Args&&... args) {
return emplace(size_, std::forward<Args>(args)...);
}
// Copies the object to the specified index
constexpr Expected<void> insert(size_t index, const T& obj) { return emplace(index, obj); }
// Moves the object to the specified index
constexpr Expected<void> insert(size_t index, T&& obj) {
return emplace(index, std::forward<T>(obj));
}
// Insert elements from another fixed vector object to the specified index
constexpr Expected<void> insert(iterator index, const_iterator start, const_iterator end) {
ssize_t count = static_cast<ssize_t>(std::distance(start, end));
size_t pos = static_cast<size_t>(std::distance(begin(), index));
if ((pos > size_) || (size_ + count > capacity_) || (count < 0)) {
return Unexpected<Error>{Error::kArgumentOutOfRange};
}
auto maybe_value = *start;
if (maybe_value) {
const T* ptr = &(*maybe_value);
if (pos < size_) {
ArrayCopyConstruct(BytePointer(data_ + pos + count), &data_[pos], size_ - pos);
}
ArrayCopyConstruct(BytePointer(data_ + pos), ptr, count);
size_ += count;
} else {
return Unexpected<Error>{Error::kInvalidIterator};
}
return kSuccess;
}
// Copies the object to the end of the vector
constexpr Expected<void> push_back(const T& obj) { return emplace_back(obj); }
// Moves the object to the end of the vector
constexpr Expected<void> push_back(T&& obj) { return emplace_back(std::forward<T>(obj)); }
// Removes the object at the specified index and destroys it
constexpr Expected<void> erase(size_t index) {
if (index >= size_) {
return Unexpected<Error>{Error::kArgumentOutOfRange};
}
if (empty()) {
return Unexpected<Error>{Error::kContainerEmpty};
}
Destruct<T>(BytePointer(&data_[index]));
size_--;
if (index < size_) {
ArrayMoveConstruct(BytePointer(&data_[index]), &data_[index + 1], size_ - index);
}
return kSuccess;
}
// Removes the object at the end of the vector and destroys it
constexpr Expected<void> pop_back() { return erase(size_ - 1); }
// Removes all objects from the vector
constexpr void clear() {
while (size_ > 0) {
Destruct<T>(BytePointer(&data_[--size_]));
}
}
// Resizes the vector by removing objects from the end if shrinking
// or by adding default objects to the end if expanding
constexpr Expected<void> resize(size_t count) {
if (count > capacity_) {
return Unexpected<Error>{Error::kArgumentOutOfRange};
}
while (count > size_) {
push_back(T());
}
while (count < size_) {
pop_back();
}
return kSuccess;
}
// Resizes the vector by removing objects from the end if shrinking
// or by adding copies of the given object to the end if expanding
constexpr Expected<void> resize(size_t count, const T& obj) {
if (count > capacity_) {
return Unexpected<Error>{Error::kArgumentOutOfRange};
}
while (count > size_) {
push_back(obj);
}
while (count < size_) {
pop_back();
}
return kSuccess;
}
protected:
// Special value for returning a success
const Expected<void> kSuccess{};
FixedVectorBase() : data_{nullptr}, capacity_{0}, size_{0} {};
// Pointer to an array of objects
T* data_;
// Maximum number of objects the container can hold
size_t capacity_;
// Number of objects stored
size_t size_;
};
// Special value used to instantiate a FixedVector with heap memory allocation
constexpr ssize_t kFixedVectorHeap = -1;
// Vector with stack memory allocation
template <typename T, ssize_t N = kFixedVectorHeap>
class FixedVector : public FixedVectorBase<T> {
public:
static_assert(N >= 0, "N must be non-negative");
constexpr FixedVector() {
data_ = ValuePointer<T>(pool_);
capacity_ = N;
}
constexpr FixedVector(const FixedVector& other) { *this = other; }
constexpr FixedVector(FixedVector&& other) { *this = std::move(other); }
constexpr FixedVector& operator=(const FixedVector& other) {
if (this != &other) {
data_ = ValuePointer<T>(pool_);
capacity_ = N;
ArrayCopyConstruct(BytePointer(data_), other.data_, other.size_);
size_ = other.size_;
}
return *this;
}
constexpr FixedVector& operator=(FixedVector&& other) {
if (this != &other) {
data_ = ValuePointer<T>(pool_);
capacity_ = N;
ArrayMoveConstruct(BytePointer(data_), other.data_, other.size_);
std::swap(size_, other.size_);
}
return *this;
}
~FixedVector() { FixedVectorBase<T>::clear(); }
private:
using FixedVectorBase<T>::data_;
using FixedVectorBase<T>::capacity_;
using FixedVectorBase<T>::size_;
// Size of memory pool for stack allocation
static constexpr size_t kPoolSize = N * sizeof(T);
// Memory pool for storing objects on the stack
byte pool_[kPoolSize];
};
// Vector with heap memory allocation
template <typename T>
class FixedVector<T, kFixedVectorHeap> : public FixedVectorBase<T> {
public:
template<typename U>
using Expected = typename FixedVectorBase<T>::template Expected<U>;
constexpr FixedVector() = default;
constexpr FixedVector(const FixedVector& other) = delete;
constexpr FixedVector(FixedVector&& other) { *this = std::move(other); }
constexpr FixedVector& operator=(const FixedVector& other) = delete;
constexpr FixedVector& operator=(FixedVector&& other) {
if (this != &other) {
std::swap(data_, other.data_);
std::swap(capacity_, other.capacity_);
std::swap(size_, other.size_);
}
return *this;
}
~FixedVector() {
FixedVectorBase<T>::clear();
DeallocateArray<T>(data_);
}
// Copies the contents of the given vector
// Current contents are discarded
// Fails if given vector is larger than current capacity
constexpr Expected<void> copy_from(const FixedVector& other) {
if (other.size_ > capacity_) {
return Unexpected<Error>{Error::kArgumentOutOfRange};
}
FixedVectorBase<T>::clear();
size_ = other.size_;
ArrayCopyConstruct(BytePointer(data_), other.data_, size_);
return kSuccess;
}
// Allocates memory to hold the specified number of elements
constexpr Expected<void> reserve(size_t capacity) {
if (capacity > capacity_) {
T* data = AllocateArray<T>(capacity);
if (!data) {
return Unexpected<Error>{Error::kOutOfMemory};
}
ArrayMoveConstruct(BytePointer(data), data_, size_);
DeallocateArray<T>(data_);
data_ = data;
capacity_ = capacity;
}
return kSuccess;
}
// Shrinks memory allocation to fit current number of elements
constexpr Expected<void> shrink_to_fit() {
if (size_ < capacity_) {
T* data = AllocateArray<T>(size_);
if (!data) {
return Unexpected<Error>(Error::kOutOfMemory);
}
ArrayMoveConstruct(BytePointer(data), data_, size_);
DeallocateArray<T>(data_);
data_ = data;
capacity_ = size_;
}
return kSuccess;
}
private:
using Error = typename FixedVectorBase<T>::Error;
using FixedVectorBase<T>::kSuccess;
using FixedVectorBase<T>::data_;
using FixedVectorBase<T>::capacity_;
using FixedVectorBase<T>::size_;
};
} // namespace nvidia
#endif // NVIDIA_GXF_COMMON_FIXED_VECTOR_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/iterator.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_GXF_COMMON_ITERATOR_HPP_
#define NVIDIA_GXF_COMMON_ITERATOR_HPP_
#include <iterator>
#include "common/expected.hpp"
#include "common/type_utils.hpp"
namespace nvidia {
namespace detail {
/// Type traits to determine if a type has `data()`
template <class, class = void> struct HasData : FalseType {};
template <class T> struct HasData<T, void_t<decltype(Declval<T>().data())>> : TrueType {};
template <class T> constexpr bool HasData_v = HasData<T>::value;
/// Type traits to determine if a type has `size()`
template <class, class = void> struct HasSize : FalseType {};
template <class T> struct HasSize<T, void_t<decltype(Declval<T>().size())>> : TrueType {};
template <class T> constexpr bool HasSize_v = HasSize<T>::value;
} // namespace detail
/// Random-access iterator for containers with elements in contiguous memory.
/// A pointer to the container is stored so the iterator does not get invalidated if elements are
/// added and/or removed from the container. Incrementing/decrementing operations will saturate
/// if the iterator reaches the end/beginning of the container. Element access is wrapped in
/// an `Expected` to prevent dereferencing invalid memory.
template <typename TContainer, typename TValue = typename TContainer::value_type>
class RandomAccessIterator {
static_assert(detail::HasData_v<TContainer>, "TContainer must have data()");
static_assert(detail::HasSize_v<TContainer>, "TContainer must have size()");
static_assert(IsIntegral_v<decltype(Declval<TContainer>().size())>,
"size() must return an integral type");
public:
enum struct Error {
kArgumentOutOfRange,
kInvalidIterator,
};
template <typename U>
using Expected = Expected<U, Error>;
// iterator traits
using iterator_category = std::random_access_iterator_tag;
using value_type = TValue;
using difference_type = std::ptrdiff_t;
using pointer = TValue*;
using reference = TValue&;
constexpr RandomAccessIterator() : container_{nullptr}, index_{-1} {}
constexpr RandomAccessIterator(TContainer& container, size_t start)
: container_{&container}, index_{0} {
*this += start;
}
template <class OContainer,
typename std::enable_if<
std::is_same<TContainer, const OContainer>::value &&
std::is_same<TValue, const typename OContainer::value_type>::value, int>::type = 0>
constexpr RandomAccessIterator(const RandomAccessIterator<OContainer>& other)
: container_{other.container_}, index_{0} {
*this += other.index_;
}
constexpr RandomAccessIterator(const RandomAccessIterator& other) = default;
constexpr RandomAccessIterator(RandomAccessIterator&& other) = default;
constexpr RandomAccessIterator& operator=(const RandomAccessIterator& other) = default;
constexpr RandomAccessIterator& operator=(RandomAccessIterator&& other) = default;
constexpr Expected<TValue&> operator*() const {
return 0 <= index_ && index_ < static_cast<difference_type>(container_->size())
? Expected<TValue&>{container_->data()[index_]}
: Unexpected<Error>{Error::kInvalidIterator};
}
constexpr Expected<TValue&> operator[](difference_type offset) const {
if (container_ == nullptr) {
return Unexpected<Error>{Error::kInvalidIterator};
}
difference_type index = index_ + offset;
return 0 <= index && index < static_cast<difference_type>(container_->size())
? Expected<TValue&>{container_->data()[index]}
: Unexpected<Error>{Error::kArgumentOutOfRange};
}
constexpr RandomAccessIterator& operator+=(difference_type offset) {
if (container_ == nullptr) {
return *this;
}
difference_type index = index_ + offset;
if (index < 0) {
index = 0;
} else if (index > static_cast<difference_type>(container_->size())) {
index = container_->size();
}
index_ = index;
return *this;
}
constexpr RandomAccessIterator& operator++() {
*this += 1;
return *this;
}
constexpr RandomAccessIterator operator++(int) {
RandomAccessIterator iter = *this;
++(*this);
return iter;
}
constexpr RandomAccessIterator& operator-=(difference_type offset) {
*this += -offset;
return *this;
}
constexpr RandomAccessIterator& operator--() {
*this -= 1;
return *this;
}
constexpr RandomAccessIterator operator--(int) {
RandomAccessIterator iter = *this;
--(*this);
return iter;
}
friend constexpr RandomAccessIterator operator+(RandomAccessIterator a, difference_type n) {
a += n;
return a;
}
friend constexpr RandomAccessIterator operator+(difference_type n, RandomAccessIterator a) {
return a + n;
}
friend constexpr RandomAccessIterator operator-(RandomAccessIterator a, difference_type n) {
a -= n;
return a;
}
friend constexpr difference_type operator-(const RandomAccessIterator& a,
const RandomAccessIterator& b) {
return a.index_ - b.index_;
}
friend constexpr bool operator==(const RandomAccessIterator& a, const RandomAccessIterator& b) {
return a.container_ == b.container_ && a.index_ == b.index_;
}
friend constexpr bool operator!=(const RandomAccessIterator& a, const RandomAccessIterator& b) {
return !(a == b);
}
private:
friend class RandomAccessIterator<const TContainer, const typename TContainer::value_type>;
/// Container pointer
TContainer* container_;
/// Iterator index
difference_type index_;
};
/// Constant Random-access iterator
template <typename TContainer>
using ConstRandomAccessIterator = RandomAccessIterator<const TContainer,
const typename TContainer::value_type>;
/// Reverse iterator
template <typename TIterator>
class ReverseIterator {
public:
using TValue = typename TIterator::value_type;
using Error = typename TIterator::Error;
template <typename U>
using Expected = Expected<U, Error>;
// iterator traits
using iterator_category = std::random_access_iterator_tag;
using value_type = TValue;
using difference_type = std::ptrdiff_t;
using pointer = TValue*;
using reference = TValue&;
constexpr explicit ReverseIterator() : iter_{} {}
constexpr explicit ReverseIterator(TIterator iter) : iter_{iter} {}
constexpr ReverseIterator(const ReverseIterator& other) = default;
constexpr ReverseIterator(ReverseIterator&& other) = default;
constexpr ReverseIterator& operator=(const ReverseIterator& other) = default;
constexpr ReverseIterator& operator=(ReverseIterator&& other) = default;
constexpr TIterator base() const { return iter_; }
constexpr Expected<TValue&> operator*() const { return *std::prev(iter_); }
constexpr Expected<TValue&> operator[](difference_type offset) const {
return std::prev(iter_)[-offset];
}
constexpr ReverseIterator& operator+=(difference_type offset) {
iter_ -= offset;
return *this;
}
constexpr ReverseIterator& operator++() {
iter_ -= 1;
return *this;
}
constexpr ReverseIterator operator++(int) {
ReverseIterator iter = *this;
++(*this);
return iter;
}
constexpr ReverseIterator& operator-=(difference_type offset) {
iter_ += offset;
return *this;
}
constexpr ReverseIterator& operator--() {
iter_ += 1;
return *this;
}
constexpr ReverseIterator operator--(int) {
ReverseIterator iter = *this;
--(*this);
return iter;
}
friend constexpr ReverseIterator operator+(ReverseIterator a, difference_type n) {
return ReverseIterator(a.iter_ - n);
}
friend constexpr ReverseIterator operator+(difference_type n, ReverseIterator a) {
return ReverseIterator(a.iter_ - n);
}
friend constexpr ReverseIterator operator-(ReverseIterator a, difference_type n) {
return ReverseIterator(a.iter_ + n);
}
friend constexpr difference_type operator-(const ReverseIterator& a, const ReverseIterator& b) {
return b.iter_ - a.iter_;
}
friend constexpr bool operator==(const ReverseIterator& a, const ReverseIterator& b) {
return a.iter_ == b.iter_;
}
friend constexpr bool operator!=(const ReverseIterator& a, const ReverseIterator& b) {
return !(a == b);
}
private:
/// Random-access iterator
TIterator iter_;
};
} // namespace nvidia
#endif // NVIDIA_GXF_COMMON_ITERATOR_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/logger.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_LOGGER_HPP_
#define NVIDIA_COMMON_LOGGER_HPP_
#include <cstdarg>
#include <cstdio>
#include <vector>
#include "gxf/logger/gxf_logger.hpp"
#define GXF_LOG_LEVEL_PANIC 0
#define GXF_LOG_LEVEL_ERROR 1
#define GXF_LOG_LEVEL_WARNING 2
#define GXF_LOG_LEVEL_INFO 3
#define GXF_LOG_LEVEL_DEBUG 4
#define GXF_LOG_LEVEL_VERBOSE 5
// clang-format off
// Set the default active logging level to VERBOSE(5) if not defined
#if !defined(GXF_LOG_ACTIVE_LEVEL)
# define GXF_LOG_ACTIVE_LEVEL 5 // GXF_LOG_LEVEL_VERBOSE
#endif
// Define GXF_LOG_ACTIVE_LEVEL before including `common/logger.hpp` to control the logging level
// at compile time. This allows you to skip logging at certain levels.
//
// Example:
// #define GXF_LOG_ACTIVE_LEVEL 2
// #include "common/logger.hpp"
// ...
//
// With this setting, logging will occur only at the WARNING(2), ERROR(1), and PANIC(0) levels.
//
// You can define GXF_LOG_ACTIVE_LEVEL in your build system. For instance, in CMake, use:
//
// target_compile_definitions(my_target PRIVATE GXF_LOG_ACTIVE_LEVEL=2)
//
// This sets the active logging level to WARNING(2) for the target `my_target`.
//
// Alternatively, define GXF_LOG_ACTIVE_LEVEL at compile time by passing `-DGXF_LOG_ACTIVE_LEVEL=2`
// directly to the compiler.
//
// In the Bazel build system, set this in your build configuration as follows:
//
// cc_binary(
// name = "my_binary",
// srcs = ["my_binary.cc"],
// copts = ["-DGXF_LOG_ACTIVE_LEVEL=2"],
// )
//
// This sets the active logging level to WARNING(2) for the target `my_binary`.
//
// Or, when using a Bazel build command:
// bazel build --copt=-DGXF_LOG_ACTIVE_LEVEL=3 //path:to_your_target
//
// This sets the active logging level to INFO(3) for the target `//path:to_your_target`.
// Logs a verbose message
#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_VERBOSE
# define GXF_LOG_VERBOSE(...) \
::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::VERBOSE, __VA_ARGS__)
#else
# define GXF_LOG_VERBOSE(...) (void)0
#endif
// Logs a debug message
#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_DEBUG
# define GXF_LOG_DEBUG(...) \
::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::DEBUG, __VA_ARGS__)
#else
# define GXF_LOG_DEBUG(...) (void)0
#endif
// Logs an informational message
#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_INFO
# define GXF_LOG_INFO(...) \
::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::INFO, __VA_ARGS__)
#else
# define GXF_LOG_INFO(...) (void)0
#endif
// Logs a warning
#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_WARNING
# define GXF_LOG_WARNING(...) \
::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::WARNING, __VA_ARGS__)
#else
# define GXF_LOG_WARNING(...) (void)0
#endif
// Logs an error
#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_ERROR
# define GXF_LOG_ERROR(...) \
::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::ERROR, __VA_ARGS__)
#else
# define GXF_LOG_ERROR(...) (void)0
#endif
// Logs a panic
#if GXF_LOG_ACTIVE_LEVEL >= GXF_LOG_LEVEL_PANIC
# define GXF_LOG_PANIC(...) \
::nvidia::Log(__FILE__, __LINE__, ::nvidia::Severity::PANIC, __VA_ARGS__)
#else
# define GXF_LOG_PANIC(...) (void)0
#endif
// clang-format on
namespace nvidia {
// Function which is used for logging. It can be changed to intercept the logged messages.
// Additional arguments can be supplied via LoggingFunctionArg.
extern void (*LoggingFunction)(const char* file, int line, Severity severity,
const char* log, void* arg);
extern void* LoggingFunctionArg;
// Default implementation of the logging function which prints to console
void DefaultConsoleLogging(const char* file, int line, Severity severity,
const char* log, void* arg);
// Redirects the output for a given log severity.
void Redirect(std::FILE* file, Severity severity = Severity::ALL);
// Sets the log severity from the environment variable.
// If the environment variable is not set or invalid, the severity is not changed.
// Returns true if the environment variable is accessible and the severity was updated from it.
bool SetSeverityFromEnv(const char* env_name = kGxfLogEnvName);
// Returns the log severity from the environment variable.
// If the environment variable is not set or invalid, returns Severity::COUNT.
// If 'error_code' is not null, it will be set to 1 if the environment variable is set but invalid,
// or to 0 otherwise.
Severity GetSeverityFromEnv(const char* env_name = kGxfLogEnvName, int* error_code = nullptr);
// Sets global log severity thus effectively disabling all logging with lower severity
void SetSeverity(Severity severity);
// Returns global log severity
Severity GetSeverity();
// Converts the message and argument into a string and pass it to LoggingFunction.
template<typename... Args>
void Log(const char* file, int line, Severity severity, const char* txt, ...) __attribute__((format(printf, 4, 5))); // NOLINT
template<typename... Args>
void Log(const char* file, int line, Severity severity, const char* txt, ...) {
va_list args1;
va_start(args1, txt);
va_list args2;
va_copy(args2, args1);
std::vector<char> buf(1 + std::vsnprintf(NULL, 0, txt, args1));
va_end(args1);
auto buf_data = buf.data();
auto buf_size = buf.size();
std::vsnprintf(buf_data, buf_size, txt, args2);
va_end(args2);
logger::GxfLogger& logger = logger::GlobalGxfLogger::instance();
logger.log(file, line, nullptr, static_cast<int>(severity), buf_data);
}
} // namespace nvidia
#endif // NVIDIA_COMMON_LOGGER_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/memory_utils.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_MEMORY_UTILS_HPP_
#define NVIDIA_COMMON_MEMORY_UTILS_HPP_
#include <cstring>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>
#include "common/byte.hpp"
namespace nvidia {
// Convert a raw byte pointer `src` to a concrete type T
template <typename T>
T* ValuePointer(byte* src) {
return reinterpret_cast<T*>(src);
}
// Convert a const raw byte pointer `src` to a concrete type T
template <typename T>
const T* ValuePointer(const byte* src) {
return reinterpret_cast<const T*>(src);
}
// Convert a type T pointer `src` to a raw byte pointer
template <typename T>
byte* BytePointer(T* src) {
return reinterpret_cast<byte*>(src);
}
// Convert a const type T pointer `src` to a raw byte pointer
template <typename T>
const byte* BytePointer(const T* src) {
return reinterpret_cast<const byte*>(src);
}
// Call the destructor for type T on the object located at `src`.
template <typename T>
void Destruct(byte* src) {
reinterpret_cast<T*>(src)->~T();
}
// Construct an object of type T with the provided arguments into the memory at `dst` with
// placement new operator.
template <typename T, typename... Args>
T* InplaceConstruct(byte* dst, Args&&... args) {
return new (dst) T{std::forward<Args>(args)...};
}
// Move construct an object of type T into the memory at `dst` with placement new operator.
template <typename T>
T* InplaceMoveConstruct(byte* dst, T&& other) {
return new (dst) T{std::forward<T>(other)};
}
// Copy construct an object of type T into the memory at `dst` with placement new operator.
template <typename T>
T* InplaceCopyConstruct(byte* dst, const T& other) {
return new (dst) T{other};
}
// Move constructs an array of objects of type T into the memory at `dst`
// Used if object is movable
template <typename T, std::enable_if_t<std::is_move_constructible<T>::value>* = nullptr>
void ArrayMoveConstruct(byte* dst, T* src, size_t count) {
// Reverse move direction to handle overlapping memory segments
const bool reverse = dst > BytePointer(src) && dst < BytePointer(src + count);
for (size_t i = 0; i < count; i++) {
const size_t index = reverse ? count - 1 - i : i;
InplaceMoveConstruct<T>(dst + sizeof(T) * index, std::move(src[index]));
}
}
// Move constructs an array of objects of type T into the memory at `dst`
// Used if object is not movable but trivially copyable
template <typename T, std::enable_if_t<!std::is_move_constructible<T>::value &&
std::is_trivially_copyable<T>::value>* = nullptr>
void ArrayMoveConstruct(byte* dst, T* src, size_t count) {
std::memmove(dst, src, sizeof(T) * count);
}
// Move constructs an array of objects of type T into the memory at `dst`
// Used if object is not movable and not trivially copyable
template <typename T, std::enable_if_t<!std::is_move_constructible<T>::value &&
!std::is_trivially_copyable<T>::value>* = nullptr>
void ArrayMoveConstruct(byte* dst, T* src, size_t count) {
// Reverse move direction to handle overlapping memory segments
const bool reverse = dst > BytePointer(src) && dst < BytePointer(src + count);
for (size_t i = 0; i < count; i++) {
const size_t index = reverse ? count - 1 - i : i;
InplaceCopyConstruct<T>(dst + sizeof(T) * index, src[index]);
}
}
// Copy constructs an array of objects of type T into the memory at `dst`
// Used if object is trivially copyable
template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value>* = nullptr>
void ArrayCopyConstruct(byte* dst, T* src, size_t count) {
std::memmove(dst, src, sizeof(T) * count);
}
// Copy constructs an array of objects of type T into the memory at `dst`
// Used if object is not trivially copyable
template <typename T, std::enable_if_t<!std::is_trivially_copyable<T>::value>* = nullptr>
void ArrayCopyConstruct(byte* dst, T* src, size_t count) {
// Reverse move direction to handle overlapping memory segments
const bool reverse = dst > BytePointer(src) && dst < BytePointer(src + count);
for (size_t i = 0; i < count; i++) {
const size_t index = reverse ? count - 1 - i : i;
InplaceCopyConstruct<T>(dst + sizeof(T) * index, src[index]);
}
}
// Allocates an array with `size` number of objects of type T
// Does not call object constructor
template <typename T>
T* AllocateArray(size_t size) {
return static_cast<T*>(::operator new(size * sizeof(T), std::nothrow));
}
// Deallocates the array `data` of objects of type T
// Does not call object destructor
template <typename T>
void DeallocateArray(T* data) {
::operator delete(data);
}
// Construct an object of type T with the provided arguments and returns a unique pointer to it
// Null pointer is returned on error
template <typename T, typename... Args>
std::unique_ptr<T> MakeUniqueNoThrow(Args&&... args) {
return std::unique_ptr<T>(new(std::nothrow) T{std::forward<Args>(args)...});
}
// Construct an object of type T with the provided arguments and returns a shared pointer to it
// Null pointer is returned on error
template <typename T, typename... Args>
std::shared_ptr<T> MakeSharedNoThrow(Args&&... args) {
return std::shared_ptr<T>(new(std::nothrow) T{std::forward<Args>(args)...});
}
} // namespace nvidia
#endif // NVIDIA_COMMON_MEMORY_UTILS_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/nvtx_helper.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_NVTX_HELPER_HPP_
#define NVIDIA_COMMON_NVTX_HELPER_HPP_
#include <string>
#include "nvtx3/nvToolsExt.h"
// Helper functions to create named color events for NVTX profiling
inline nvtxEventAttributes_t CreateGreenEvent(const std::string& message, uint32_t category) {
nvtxEventAttributes_t eventAttrib = {0};
eventAttrib.version = NVTX_VERSION;
eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
eventAttrib.colorType = NVTX_COLOR_ARGB;
eventAttrib.color = 0xFF76b900; // NVIDIA GREEN
eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
eventAttrib.message.ascii = message.c_str();
eventAttrib.category = category;
return eventAttrib;
}
inline nvtxEventAttributes_t CreateRedEvent(const std::string& message, uint32_t category) {
nvtxEventAttributes_t eventAttrib = {0};
eventAttrib.version = NVTX_VERSION;
eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
eventAttrib.colorType = NVTX_COLOR_ARGB;
eventAttrib.color = 0xFFFe2712; // Red
eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
eventAttrib.message.ascii = message.c_str();
eventAttrib.category = category;
return eventAttrib;
}
inline nvtxEventAttributes_t CreateBlackEvent(const std::string& message, uint32_t category) {
nvtxEventAttributes_t eventAttrib = {0};
eventAttrib.version = NVTX_VERSION;
eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
eventAttrib.colorType = NVTX_COLOR_ARGB;
eventAttrib.color = 0xFF010203; // Rich black
eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
eventAttrib.message.ascii = message.c_str();
eventAttrib.category = category;
return eventAttrib;
}
inline nvtxEventAttributes_t CreateBlueEvent(const std::string& message, uint32_t category) {
nvtxEventAttributes_t eventAttrib = {0};
eventAttrib.version = NVTX_VERSION;
eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
eventAttrib.colorType = NVTX_COLOR_ARGB;
eventAttrib.color = 0xFF66a1fe; // Light Blue
eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
eventAttrib.message.ascii = message.c_str();
eventAttrib.category = category;
return eventAttrib;
}
#endif // NVIDIA_COMMON_NVTX_HELPER_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/singleton.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_SINGLETON_HPP_
#define NVIDIA_COMMON_SINGLETON_HPP_
namespace gxf {
// A singleton which supports creation at pre-execution time
// Usage: For a class `MyType` with a member function `myMember` you can just write:
// Singleton<MyType>::Get().myMember();
// This will automatically create a singleton, i.e. return the same instance each time you call Get.
// The constructor of MyType will be called at pre-execution time, i.e. before entering main.
// If you use multiple singletons they will all be created at pre-execution time, but you should
// not rely on a particular instantiation order.
template <typename T>
struct Singleton {
public:
Singleton& operator=(Singleton&) = delete;
// Get the singleton
static T& Get() {
static T singleton;
Use(dummy_);
return singleton;
}
private:
// Helpers to force pre-execution time
static void Use(const T&) {}
static T& dummy_;
};
// Force instantiation of the singleton at pre-execution time
template <typename T>
T& Singleton<T>::dummy_ = Singleton<T>::Get();
} // namespace gxf
#endif // NVIDIA_COMMON_SINGLETON_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/span.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_GXF_COMMON_SPAN_HPP_
#define NVIDIA_GXF_COMMON_SPAN_HPP_
#include "common/byte.hpp"
#include "common/expected.hpp"
#include "common/iterator.hpp"
#include "common/type_utils.hpp"
namespace nvidia {
namespace detail {
/// Type traits to enable comparing `Span<T>` with `Span<const T>`
template <class T, class U> using EnableIfComparable_t = EnableIf_t<
IsSame_v<RemoveConst_t<T>, RemoveConst_t<U>>
>;
/// Type traits to determine if type stores elements in contiguous memory
template <class T> using EnableIfContiguous_t = EnableIf_t<Conjunction_v<HasData<T>, HasSize<T>>>;
} // namespace detail
/// Container to hold a pointer and size for contiguous memory.
/// `Span` can be passed between functions and components and ensures that the size of the array is
/// always available and can be checked for safe memory access. `Span` only wraps existing memory.
template <typename T>
class Span {
public:
using element_type = T;
using value_type = RemoveCV_t<element_type>;
using size_type = size_t;
using iterator = RandomAccessIterator<const Span, element_type>;
using reverse_iterator = ReverseIterator<iterator>;
/// Custom error codes for `Span`
enum struct Error {
kArgumentOutOfRange,
kContainerEmpty,
};
/// `Expected` which uses `Span::Error`
template <typename U>
using Expected = Expected<U, Error>;
constexpr Span(T* data, size_t size) : data_{data}, size_{data != nullptr ? size : 0} {}
constexpr Span() : Span(nullptr, 0) {}
template <size_t N>
constexpr Span(T (&array)[N]) : Span(array, N) {}
/// Conversion from other types that have `data()` and `size()` functions
template <typename U, typename = detail::EnableIfContiguous_t<U>>
constexpr Span(U& other) : Span(other.data(), other.size()) {}
/// Implicit conversion from `Span<T>` to `Span<const T>`
operator Span<const T>() const { return Span<const T>(data_, size_); }
~Span() = default;
constexpr Span(const Span& other) = default;
constexpr Span(Span&& other) = default;
constexpr Span& operator=(const Span&) = default;
constexpr Span& operator=(Span&&) = default;
constexpr iterator begin() const { return iterator(*this, 0); }
constexpr iterator end() const { return iterator(*this, size_); }
constexpr reverse_iterator rbegin() const { return reverse_iterator(end()); }
constexpr reverse_iterator rend() const { return reverse_iterator(begin()); }
constexpr Expected<T&> operator[](size_t index) const { return at(index); }
/// Returns a pointer to the underlying data
constexpr T* data() const { return data_; }
/// Returns the number of elements in the `Span`
constexpr size_t size() const { return size_; }
/// Returns the size of the `Span` in bytes
constexpr size_t size_bytes() const { return size_ * sizeof(T); }
/// Returns true if the `Span` has no elements
constexpr bool empty() const { return size_ == 0; }
/// Returns a reference to the element at `index`
constexpr Expected<T&> at(size_t index) const {
return index < size_ ? Expected<T&>{data_[index]}
: Unexpected<Error>{Error::kArgumentOutOfRange};
}
/// Returns a reference to the first element
constexpr Expected<T&> front() const {
return !empty() ? Expected<T&>{data_[0]}
: Unexpected<Error>{Error::kContainerEmpty};
}
/// Returns a reference to the last element
constexpr Expected<T&> back() const {
return !empty() ? Expected<T&>{data_[size_ - 1]}
: Unexpected<Error>{Error::kContainerEmpty};
}
/// Returns a `Span` consisting of `count` elements starting from `offset`
constexpr Expected<Span> subspan(size_t offset, size_t count) const {
return offset <= size_ && count <= size_ && offset + count <= size_
? Expected<Span>{Span(data_ + offset, count)}
: Unexpected<Error>{Error::kArgumentOutOfRange};
}
/// Returns a `Span` starting from `offset`
constexpr Expected<Span> subspan(size_t offset) const { return subspan(offset, size_ - offset); }
/// Returns a `Span` consisting of the first `count` elements
constexpr Expected<Span> first(size_t count) const { return subspan(0, count); }
/// Returns a `Span` consisting of the last `count` elements
constexpr Expected<Span> last(size_t count) const { return subspan(size_ - count, count); }
private:
/// Pointer to data
T* data_;
/// Size of data
size_t size_;
};
template <typename T, typename U, typename = detail::EnableIfComparable_t<T, U>>
constexpr bool operator==(const Span<T>& a, const Span<U>& b) {
if (a.size() != b.size()) {
return false;
}
if (a.data() == b.data()) {
return true;
}
for (size_t i = 0; i < a.size(); i++) {
if (a.data()[i] != b.data()[i]) {
return false;
}
}
return true;
}
template <typename T, typename U, typename = detail::EnableIfComparable_t<T, U>>
constexpr bool operator!=(const Span<T>& a, const Span<U>& b) { return !(a == b); }
} // namespace nvidia
#endif // NVIDIA_GXF_COMMON_SPAN_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/strong_type.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_GXF_COMMON_STRONG_TYPE_HPP_
#define NVIDIA_GXF_COMMON_STRONG_TYPE_HPP_
#include <utility>
#include "common/type_utils.hpp"
namespace nvidia {
/// The base type for a
/// [strong type](https://www.fluentcpp.com/2016/12/08/strong-types-for-strong-interfaces).
/// It is useful for making lightweight types which are distinct. Unlike type aliases
/// (@c typedef or @c using), two @c StrongType types are not substitutable, even if the
/// backing type is the same.
///
/// The primary use case for this type is numeric identifiers. For example, imagine a sensor
/// system where the sensor is identified by a @c uint32_t. Beyond being a 32-bit integer, this
/// value shares almost no properties with the C type. Arithmetic and bit shifts do not make a
/// lot of sense for this value -- there is no meaning to the result of multiplication between
/// two sensor IDs. Comparing a sensor ID to any non-sensor ID value is probably a bug. By
/// wrapping ID values into a dedicated @c SensorId @c StrongType, this behavior is prevented.
///
/// @code
/// // Create two types: Foo and Bar, both wrapping a uint64_t
/// using Foo = StrongType<struct foo_t, uint64_t>;
/// using Bar = StrongType<struct bar_t, uint64_t>;
///
/// void fooOnly(const Foo&);
/// void barOnly(const Bar&);
///
/// int main() {
/// // Values must be constructed explicitly
/// auto foo = Foo(106);
/// auto bar = Bar(314);
///
/// fooOnly(foo); // <- legal
/// fooOnly(bar); // <- illegal: a Bar type is distinct from Foo
/// fooOnly(foo.value()); // <- illegal: no implicit construction
/// barOnly(foo); // <- illegal: foo is not a Bar
/// }
/// @endcode
template <typename TName, typename TValue>
class StrongType {
public:
/// The underlying type of this type.
using value_type = TValue;
/// Default-construct an instance. This overload is only enabled if
/// @ref value_type is default-constructible.
constexpr StrongType() = default;
/// Construct an instance from @a value.
///
/// @param value The value to convert from.
template <typename UValue>
constexpr explicit
StrongType(UValue&& value) noexcept(IsNothrowConstructible_v<value_type, UValue>)
: value_(std::forward<UValue>(value)) {}
constexpr explicit operator value_type() const& noexcept { return value_; }
constexpr explicit operator value_type() & noexcept { return value_; }
constexpr explicit operator value_type() && noexcept { return value_; }
constexpr value_type const& value() const & noexcept { return value_; }
constexpr value_type& value() & noexcept { return value_; }
constexpr value_type&& value() && noexcept { return std::move(value_); }
constexpr value_type const* operator->() const noexcept { return &value_; }
constexpr value_type* operator->() noexcept { return &value_; }
/// Comparison operatorions for the underlying type.
friend constexpr bool operator==(const StrongType& lhs, const StrongType& rhs) {
return lhs.value() == rhs.value();
}
friend constexpr bool operator!=(const StrongType& lhs, const StrongType& rhs) {
return lhs.value() != rhs.value();
}
friend constexpr bool operator<=(const StrongType& lhs, const StrongType& rhs) {
return lhs.value() <= rhs.value();
}
friend constexpr bool operator>=(const StrongType& lhs, const StrongType& rhs) {
return lhs.value() >= rhs.value();
}
friend constexpr bool operator<(const StrongType& lhs, const StrongType& rhs) {
return lhs.value() < rhs.value();
}
friend constexpr bool operator>(const StrongType& lhs, const StrongType& rhs) {
return lhs.value() > rhs.value();
}
private:
/// The underlying value of this type.
value_type value_;
};
} // namespace nvidia
#endif // NVIDIA_GXF_COMMON_STRONG_TYPE_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/type_name.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_TYPE_NAME_HPP_
#define NVIDIA_COMMON_TYPE_NAME_HPP_
#include <cstdint>
#if defined(__clang__)
inline char* TypenameAsStringImpl(const char* begin, char* output, int32_t max_length) {
// Return nullptr since this is not implemented
return nullptr;
}
#elif defined(__GNUC__)
#include "type_name_gnuc.hpp"
#elif defined(_MSC_VER)
// Not yet implemented
#endif
namespace nvidia {
namespace helper {
/**
* Returns the pretty function name. It includes the complete function name along with the namespace
* for template parameters.
* Compiler using gcc-13 or later strips the namespace of the template parameter if
* PRETTY_FUNCTION is called in the same namespace as that of the namespace of template parameter.
* Compiler does not strip the namespace if the function that calls the PRETTY_FUNCTION macro is
* called in a different namespace.
*
* @return the pretty function name as a const char*
*/
template <typename>
const char* PrettyFunctionName() {
return __PRETTY_FUNCTION__;
}
/**
* Returns the sizeof the pretty function name.
*/
template <typename>
constexpr int32_t PrettyFunctionSize() {
return sizeof(__PRETTY_FUNCTION__);
}
} // namespace helper
} // namespace nvidia
namespace nvidia {
// Gives a string representation of the name of a C++ type.
//
// The function will compute the typename during the first invocation and store it in heap memory.
// Computation of the typename is linear in the length of the typename and does not involve dynamic
// memory allocations.
//
// For example:
// namespace foo {
// struct Bar {};
// } // namespace
// TyenameAsString<foo::Bar>(); // returns "foo::Bar"
//
// Note: Only "simple" class types in global namespace or a "normal" namespaces are guaranteed to
// work. Templates, lambdas and anonymous namespaces are not guaranteed to work as expected.
template <typename T>
const char* TypenameAsString() {
// Ideally the typename string would be computed at compile time, however this does not seem to
// be possible. Thus the typename string is computed the first time this function is evaluated
// and cached for future function evaluations.
const char* template_name = nvidia::helper::PrettyFunctionName<T>();
// Use upper bound to be safe.
constexpr int32_t kMaxNameLength = nvidia::helper::PrettyFunctionSize<T>();
static char s_name[kMaxNameLength] = {0}; // Initialize with 0 to get a null-terminated string.
static char* result = s_name;
if (s_name[0] == 0 && result != nullptr) { // Check for first invocation of this function.
result = TypenameAsStringImpl(template_name, s_name, kMaxNameLength);
}
return result;
}
} // namespace nvidia
#endif // NVIDIA_COMMON_TYPE_NAME_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/type_name_gnuc.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_TYPE_NAME_GNUC_HPP_
#define NVIDIA_COMMON_TYPE_NAME_GNUC_HPP_
#include <cstdint>
namespace nvidia {
// For the GNU compiler __PRETTY_FUNCTION__ is a null-terminated string with the following form:
// const char* nvidia::TypenameAsString() [with T = nvidia::gxf::Component]
// We would like to extract the type name as "nvidia::gxf::Component".
// The result is stored in the given string 'output'. If the type name is longer than max_length
// or another error occurs the function returns nullptr; otherwise 'output' is returned.
char* TypenameAsStringGnuC(const char* begin, char* output, int32_t max_length);
// Compiler-specific implementation of the TypenameAsString function.
inline char* TypenameAsStringImpl(const char* begin, char* output, int32_t max_length) {
return TypenameAsStringGnuC(begin, output, max_length);
}
} // namespace nvidia
#endif // NVIDIA_COMMON_TYPE_NAME_GNUC_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/type_utils.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_COMMON_TYPE_UTILS_HPP_
#define NVIDIA_COMMON_TYPE_UTILS_HPP_
#include <cstdint>
// GXF definitions for common <type_traits> class definitions. These should behave identically
// ISO standard definitions. They are defined locally to minimize dependencies of core GXF code
// on any stl implementations.
namespace nvidia {
// https://en.cppreference.com/w/cpp/types/void_t
template <class...> using void_t = void;
// https://en.cppreference.com/w/cpp/types/type_identity
template <class T> struct TypeIdentity { using type = T; };
template <class T> using TypeIdentity_t = typename TypeIdentity<T>::type;
// https://en.cppreference.com/w/cpp/types/integral_constant
template <class T, T v> struct IntegralConstant { static constexpr T value = v; };
template <bool B> struct BoolConstant : IntegralConstant<bool, B> {};
struct TrueType : BoolConstant<true> {};
struct FalseType : BoolConstant<false> {};
// https://en.cppreference.com/w/cpp/types/conditional
template <bool B, class T, class F> struct Conditional : TypeIdentity<T> {};
template<class T, class F> struct Conditional<false, T, F> : TypeIdentity<F> {};
template <bool B, class T, class F> using Conditional_t = typename Conditional<B, T, F>::type;
// https://en.cppreference.com/w/cpp/types/conjunction
template <class...>
struct Conjunction : TrueType {};
template <class B, class... Bs>
struct Conjunction<B, Bs...> : Conditional<B::value, Conjunction<Bs...>, B>::type {};
template <class... Bs> constexpr bool Conjunction_v = Conjunction<Bs...>::value;
// https://en.cppreference.com/w/cpp/types/disjunction
template <class...>
struct Disjunction : FalseType {};
template <class B, class... Bs>
struct Disjunction<B, Bs...> : Conditional<B::value, B, Disjunction<Bs...>>::type {};
template <class... Bs> constexpr bool Disjunction_v = Disjunction<Bs...>::value;
// https://en.cppreference.com/w/cpp/types/negation
template <class B> struct Negation : BoolConstant<!static_cast<bool>(B::value)> {};
template <class B> constexpr bool Negation_v = Negation<B>::value;
// https://en.cppreference.com/w/cpp/types/remove_reference
template <class T> struct RemoveReference : TypeIdentity<T> {};
template <class T> struct RemoveReference<T&> : TypeIdentity<T> {};
template <class T> struct RemoveReference<T&&> : TypeIdentity<T> {};
template <class T> using RemoveReference_t = typename RemoveReference<T>::type;
// https://en.cppreference.com/w/cpp/types/remove_cv
template <class T> struct RemoveCV : TypeIdentity<T> {};
template <class T> struct RemoveCV<const T> : TypeIdentity<T> {};
template <class T> struct RemoveCV<volatile T> : TypeIdentity<T> {};
template <class T> struct RemoveCV<const volatile T> : TypeIdentity<T> {};
template <class T> using RemoveCV_t = typename RemoveCV<T>::type;
template <class T> struct RemoveConst : TypeIdentity<T> {};
template <class T> struct RemoveConst<const T> : TypeIdentity<T> {};
template <class T> using RemoveConst_t = typename RemoveConst<T>::type;
template <class T> struct RemoveVolatile : TypeIdentity<T> {};
template <class T> struct RemoveVolatile<volatile T> : TypeIdentity<T> {};
template <class T> using RemoveVolatile_t = typename RemoveVolatile<T>::type;
// https://en.cppreference.com/w/cpp/types/remove_cvref
template <class T> struct RemoveCVRef : RemoveCV<typename RemoveReference<T>::type>{};
template <class T> using RemoveCVRef_t = typename RemoveCVRef<T>::type;
// https://en.cppreference.com/w/cpp/types/add_reference
template <class T>
struct AddLvalueReference {
private:
template <class U> static constexpr TypeIdentity<U&> Test(void*);
template <class U> static constexpr TypeIdentity<U> Test(...);
public:
using type = typename decltype(Test<T>(nullptr))::type;
};
template <class T>
struct AddRvalueReference {
private:
template <class U> static constexpr TypeIdentity<U&&> Test(void*);
template <class U> static constexpr TypeIdentity<U> Test(...);
public:
using type = typename decltype(Test<T>(nullptr))::type;
};
template <class T> using AddLvalueReference_t = typename AddLvalueReference<T>::type;
template <class T> using AddRvalueReference_t = typename AddRvalueReference<T>::type;
// https://en.cppreference.com/w/cpp/utility/declval
template <class T>
AddRvalueReference_t<T> Declval() noexcept {
static_assert(Conditional_t<false, T, FalseType>::value,
"Declval() cannot be used in an evaluated context.");
}
// https://en.cppreference.com/w/cpp/types/decay
template <class T>
struct Decay {
private:
template <class U> static constexpr auto Id(U u) noexcept { return u; }
template <class U> static constexpr decltype(Id(Declval<U>())) Test(void*);
template <class> static constexpr void Test(...) {}
public:
using type = decltype(Test<T>(nullptr));
};
template <class T> using Decay_t = typename Decay<T>::type;
// https://en.cppreference.com/w/cpp/types/enable_if
template <bool, class = void> struct EnableIf {};
template <class T> struct EnableIf<true, T> : TypeIdentity<T> {};
template <bool B, class T = void> using EnableIf_t = typename EnableIf<B, T>::type;
// https://en.cppreference.com/w/cpp/types/is_same
template <class, class> struct IsSame : FalseType {};
template <class T> struct IsSame<T, T> : TrueType {};
template <class T, class U> constexpr bool IsSame_v = IsSame<T, U>::value;
// https://en.cppreference.com/w/cpp/types/is_void
template <class T> struct IsVoid : IsSame<void, typename RemoveCV<T>::type> {};
template <class T> constexpr bool IsVoid_v = IsVoid<T>::value;
// // https://en.cppreference.com/w/cpp/types/is_const
template <class T> struct IsConst : FalseType {};
template <class T> struct IsConst<const T> : TrueType {};
template <class T> constexpr bool IsConst_v = IsConst<T>::value;
// https://en.cppreference.com/w/cpp/types/is_reference
template <class> struct IsReference : FalseType {};
template <class T> struct IsReference<T&> : TrueType {};
template <class T> struct IsReference<T&&> : TrueType {};
template <class T> constexpr bool IsReference_v = IsReference<T>::value;
// https://en.cppreference.com/w/cpp/types/is_constructible
template <class T, class... Args>
struct IsConstructible {
private:
template<class V, class = decltype(static_cast<T>(Declval<V>()))>
static constexpr bool TestCast(void*) { return true; }
template<class...>
static constexpr bool TestCast(...) { return false; }
template <int, class, class = void>
struct Test : FalseType {};
template <class U>
struct Test<1, U, void> : BoolConstant<TestCast<Args...>(nullptr)> {};
template <int I, class U>
struct Test<I, U, void_t<decltype(new U(Declval<Args>()...))>> : TrueType {};
public:
static constexpr bool value = Test<sizeof...(Args), T>::value;
};
template <class T, class... Args>
constexpr bool IsConstructible_v = IsConstructible<T, Args...>::value;
// https://en.cppreference.com/w/cpp/types/is_default_constructible
template <class T>
using IsDefaultConstructible = IsConstructible<T>;
template <class T>
constexpr bool IsDefaultConstructible_v = IsDefaultConstructible<T>::value;
// https://en.cppreference.com/w/cpp/types/is_nothrow_constructible
template <class T, class... Args>
struct IsNothrowConstructible {
private:
template<class V, bool Result = noexcept(static_cast<T>(Declval<V>()))>
static constexpr bool TestCast(void*) { return Result; }
template<class...>
static constexpr bool TestCast(...) { return false; }
template<int, class, class = void>
struct Test : FalseType {};
template<class U>
struct Test<0, U, void_t<decltype(U())>> : BoolConstant<noexcept(U())> {};
template<class U>
struct Test<1, U, void> : BoolConstant<TestCast<Args...>(nullptr)> {};
template<int I, class U>
struct Test<I, U, void_t<decltype(new U(Declval<Args>()...))>>
: BoolConstant<noexcept(new U(Declval<Args>()...))> {};
public:
static constexpr bool value = Test<sizeof...(Args), T>::value;
};
template <class T, class U>
constexpr bool IsNothrowConstructible_v = IsNothrowConstructible<T, U>::value;
// https://en.cppreference.com/w/cpp/types/is_nothrow_default_constructible
template <class T>
using IsNothrowDefaultConstructible = IsNothrowConstructible<T>;
template <class T>
constexpr bool IsNothrowDefaultConstructible_v = IsNothrowDefaultConstructible<T>::value;
// https://en.cppreference.com/w/cpp/types/is_convertible
template <class From, class To>
struct IsConvertible {
private:
template <class F, class T, class = decltype(Declval<T(&)(T)>()(Declval<F>()))>
static constexpr bool Test(void*) { return true; }
template <class, class>
static constexpr bool Test(...) { return false; }
public:
static constexpr bool value = (IsVoid_v<From> && IsVoid_v<To>) || Test<From, To>(nullptr);
};
template <class From, class To>
constexpr bool IsConvertible_v = IsConvertible<From, To>::value;
// https://en.cppreference.com/w/cpp/types/is_convertible
template <class From, class To>
struct IsNothrowConvertible {
private:
template <class T>
static constexpr T DecayFunc(T) noexcept;
template <class F, class T, bool Result = noexcept(DecayFunc<T>(Declval<F>()))>
static constexpr bool Test(void*) { return Result; }
template <class, class>
static constexpr bool Test(...) { return false; }
public:
static constexpr bool value = (IsVoid_v<From> && IsVoid_v<To>) || Test<From, To>(nullptr);
};
template <class From, class To>
constexpr bool IsNothrowConvertible_v = IsNothrowConvertible<From, To>::value;
// https://en.cppreference.com/w/cpp/types/is_assignable
template <class, class, class = void>
struct IsAssignable : FalseType {};
template <class T, class U>
struct IsAssignable<T, U, void_t<decltype(Declval<T>() = Declval<U>())>> : TrueType{};
template <class T, class U> constexpr bool IsAssignable_v = IsAssignable<T, U>::value;
// https://en.cppreference.com/w/cpp/types/is_integral
template <class T>
struct IsIntegral : BoolConstant<
IsSame_v<bool, typename RemoveCV<T>::type> ||
IsSame_v<int8_t, typename RemoveCV<T>::type> ||
IsSame_v<uint8_t, typename RemoveCV<T>::type> ||
IsSame_v<int16_t, typename RemoveCV<T>::type> ||
IsSame_v<uint16_t, typename RemoveCV<T>::type> ||
IsSame_v<int32_t, typename RemoveCV<T>::type> ||
IsSame_v<uint32_t, typename RemoveCV<T>::type> ||
IsSame_v<int64_t, typename RemoveCV<T>::type> ||
IsSame_v<uint64_t, typename RemoveCV<T>::type>> {};
template <class T> constexpr bool IsIntegral_v = IsIntegral<T>::value;
// https://en.cppreference.com/w/cpp/types/is_floating_point
template <class T>
struct IsFloatingPoint : BoolConstant<
IsSame_v<float, typename RemoveCV<T>::type> ||
IsSame_v<double, typename RemoveCV<T>::type> ||
IsSame_v<long double, typename RemoveCV<T>::type>> {};
template <class T> constexpr bool IsFloatingPoint_v = IsFloatingPoint<T>::value;
// https://en.cppreference.com/w/cpp/types/is_arithmetic
template <class T>
struct IsArithmetic : BoolConstant<IsIntegral_v<T> || IsFloatingPoint_v<T>> {};
template <class T> constexpr bool IsArithmetic_v = IsArithmetic<T>::value;
// https://en.cppreference.com/w/cpp/types/is_signed
template <class T, bool = IsArithmetic_v<T>> struct IsSigned : BoolConstant<(T(-1) < T(0))> {};
template <class T> struct IsSigned<T, false> : FalseType {};
template <class T> constexpr bool IsSigned_v = IsSigned<T>::value;
// https://en.cppreference.com/w/cpp/types/is_unsigned
template <class T, bool = IsArithmetic_v<T>> struct IsUnsigned : BoolConstant<(T(0) < T(-1))> {};
template <class T> struct IsUnsigned<T, false> : FalseType {};
template <class T> constexpr bool IsUnsigned_v = IsUnsigned<T>::value;
// https://en.cppreference.com/w/cpp/types/make_signed
template <class T, class = EnableIf_t<IsIntegral_v<T>>> struct MakeSigned : TypeIdentity<T> {};
template <> struct MakeSigned<uint8_t> : TypeIdentity<int8_t> {};
template <> struct MakeSigned<uint16_t> : TypeIdentity<int16_t> {};
template <> struct MakeSigned<uint32_t> : TypeIdentity<int32_t> {};
template <> struct MakeSigned<uint64_t> : TypeIdentity<int64_t> {};
template <class T> using MakeSigned_t = typename MakeSigned<T>::type;
// https://en.cppreference.com/w/cpp/types/make_unsigned
template <class T, class = EnableIf_t<IsIntegral_v<T>>> struct MakeUnsigned : TypeIdentity<T> {};
template <> struct MakeUnsigned<int8_t> : TypeIdentity<uint8_t> {};
template <> struct MakeUnsigned<int16_t> : TypeIdentity<uint16_t> {};
template <> struct MakeUnsigned<int32_t> : TypeIdentity<uint32_t> {};
template <> struct MakeUnsigned<int64_t> : TypeIdentity<uint64_t> {};
template <class T> using MakeUnsigned_t = typename MakeUnsigned<T>::type;
} // namespace nvidia
#endif // NVIDIA_COMMON_TYPE_UTILS_HPP_
================================================
FILE: isaac_ros_gxf/gxf/core/include/common/unique_index_map.hpp
================================================
// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES
// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef NVIDIA_GXF_COMMON_UNIQUE_INDEX_MAP_HPP_
#define NVIDIA_GXF_COMMON_UNIQUE_INDEX_MAP_HPP_
#include "common/expected.hpp"
namespace nvidia {
// Provides a basic fixed capacity container for tracking objects and assigning a unique id to every
// object inserted. It provides constant time insert/delete/access for all elements with the
// generated uid. This container guarantees that uids are never reused, and will return an
// Unexpected Error if it runs out of capacity.
template <typename T>
class UniqueIndexMap {
private:
// number of bits to use for holding the version number
static constexpr uint64_t kVersionSize = 32;
// number of bits to use for holding the index into the underlying container
static constexpr uint64_t kIndexSize = 32;
// bitmask for Version number
static constexpr uint64_t kVersionMask = ((1ULL << kVersionSize) - 1ULL) << kIndexSize;
// bitmask for Index number
static constexpr uint64_t kIndexMask = (1ULL << kIndexSize) - 1ULL;
static_assert(kIndexSize + kVersionSize == 64, "Invalid UID bit l
gitextract_a_s3rfnt/
├── .gitattributes
├── .gitignore
├── LICENSE
├── README.md
├── SECURITY.md
├── isaac_ros_gxf/
│ ├── CMakeLists.txt
│ ├── cmake/
│ │ ├── isaac_ros_gxf-extras.cmake
│ │ └── modules/
│ │ └── FindGXF.cmake
│ ├── gxf/
│ │ ├── AMENT_IGNORE
│ │ └── core/
│ │ └── include/
│ │ ├── common/
│ │ │ ├── assert.hpp
│ │ │ ├── backtrace.hpp
│ │ │ ├── byte.hpp
│ │ │ ├── endian.hpp
│ │ │ ├── expected.hpp
│ │ │ ├── fixed_map.hpp
│ │ │ ├── fixed_string.hpp
│ │ │ ├── fixed_vector.hpp
│ │ │ ├── iterator.hpp
│ │ │ ├── logger.hpp
│ │ │ ├── memory_utils.hpp
│ │ │ ├── nvtx_helper.hpp
│ │ │ ├── singleton.hpp
│ │ │ ├── span.hpp
│ │ │ ├── strong_type.hpp
│ │ │ ├── type_name.hpp
│ │ │ ├── type_name_gnuc.hpp
│ │ │ ├── type_utils.hpp
│ │ │ ├── unique_index_map.hpp
│ │ │ └── yaml_parser.hpp
│ │ ├── dlpack/
│ │ │ └── dlpack.h
│ │ ├── gxf/
│ │ │ ├── app/
│ │ │ │ ├── application.hpp
│ │ │ │ ├── arg.hpp
│ │ │ │ ├── arg_parse.hpp
│ │ │ │ ├── config_parser.hpp
│ │ │ │ ├── driver.hpp
│ │ │ │ ├── entity_group.hpp
│ │ │ │ ├── extension_manager.hpp
│ │ │ │ ├── graph_entity.hpp
│ │ │ │ ├── graph_utils.hpp
│ │ │ │ ├── proxy_component.hpp
│ │ │ │ ├── segment.hpp
│ │ │ │ └── worker.hpp
│ │ │ ├── behavior_tree/
│ │ │ │ ├── constant_behavior.hpp
│ │ │ │ ├── entity_count_failure_repeat_controller.hpp
│ │ │ │ ├── parallel_behavior.hpp
│ │ │ │ ├── repeat_behavior.hpp
│ │ │ │ ├── selector_behavior.hpp
│ │ │ │ ├── sequence_behavior.hpp
│ │ │ │ ├── switch_behavior.hpp
│ │ │ │ └── timer_behavior.hpp
│ │ │ ├── core/
│ │ │ │ ├── common_expected_macro.hpp
│ │ │ │ ├── component.hpp
│ │ │ │ ├── entity.hpp
│ │ │ │ ├── expected.hpp
│ │ │ │ ├── expected_macro.hpp
│ │ │ │ ├── filepath.hpp
│ │ │ │ ├── gxf.h
│ │ │ │ ├── gxf_ext.h
│ │ │ │ ├── handle.hpp
│ │ │ │ ├── parameter.hpp
│ │ │ │ ├── parameter_parser.hpp
│ │ │ │ ├── parameter_parser_std.hpp
│ │ │ │ ├── parameter_registrar.hpp
│ │ │ │ ├── parameter_storage.hpp
│ │ │ │ ├── parameter_wrapper.hpp
│ │ │ │ ├── registrar.hpp
│ │ │ │ ├── resource.hpp
│ │ │ │ ├── resource_manager.hpp
│ │ │ │ ├── resource_registrar.hpp
│ │ │ │ └── type_registry.hpp
│ │ │ ├── cuda/
│ │ │ │ ├── cuda_allocator.hpp
│ │ │ │ ├── cuda_buffer.hpp
│ │ │ │ ├── cuda_common.hpp
│ │ │ │ ├── cuda_event.hpp
│ │ │ │ ├── cuda_scheduling_terms.hpp
│ │ │ │ ├── cuda_stream.hpp
│ │ │ │ ├── cuda_stream_id.hpp
│ │ │ │ ├── cuda_stream_pool.hpp
│ │ │ │ ├── cuda_stream_sync.hpp
│ │ │ │ ├── stream_ordered_allocator.hpp
│ │ │ │ └── tests/
│ │ │ │ ├── convolution.h
│ │ │ │ ├── green_context_with_smid.h
│ │ │ │ └── test_cuda_helper.hpp
│ │ │ ├── logger/
│ │ │ │ ├── gxf_logger.hpp
│ │ │ │ └── logger.hpp
│ │ │ ├── multimedia/
│ │ │ │ ├── audio.hpp
│ │ │ │ ├── camera.hpp
│ │ │ │ └── video.hpp
│ │ │ ├── network/
│ │ │ │ ├── tcp_client.hpp
│ │ │ │ ├── tcp_client_socket.hpp
│ │ │ │ ├── tcp_codelet.hpp
│ │ │ │ ├── tcp_server.hpp
│ │ │ │ └── tcp_server_socket.hpp
│ │ │ ├── npp/
│ │ │ │ ├── nppi_mul_c.hpp
│ │ │ │ └── nppi_set.hpp
│ │ │ ├── rmm/
│ │ │ │ └── rmm_allocator.hpp
│ │ │ ├── serialization/
│ │ │ │ ├── component_serializer.hpp
│ │ │ │ ├── endpoint.hpp
│ │ │ │ ├── entity_recorder.hpp
│ │ │ │ ├── entity_replayer.hpp
│ │ │ │ ├── entity_serializer.hpp
│ │ │ │ ├── file.hpp
│ │ │ │ ├── file_stream.hpp
│ │ │ │ ├── serialization_buffer.hpp
│ │ │ │ ├── std_component_serializer.hpp
│ │ │ │ ├── std_entity_id_serializer.hpp
│ │ │ │ ├── std_entity_serializer.hpp
│ │ │ │ ├── tests/
│ │ │ │ │ └── serialization_tester.hpp
│ │ │ │ └── tid_hash.hpp
│ │ │ ├── std/
│ │ │ │ ├── allocator.hpp
│ │ │ │ ├── async_buffer_receiver.hpp
│ │ │ │ ├── async_buffer_transmitter.hpp
│ │ │ │ ├── block_memory_pool.hpp
│ │ │ │ ├── clock.hpp
│ │ │ │ ├── codelet.hpp
│ │ │ │ ├── complex.hpp
│ │ │ │ ├── component_allocator.hpp
│ │ │ │ ├── component_factory.hpp
│ │ │ │ ├── controller.hpp
│ │ │ │ ├── cpu_thread.hpp
│ │ │ │ ├── cuda_green_context.hpp
│ │ │ │ ├── cuda_green_context_pool.hpp
│ │ │ │ ├── default_extension.hpp
│ │ │ │ ├── dlpack_utils.hpp
│ │ │ │ ├── double_buffer_receiver.hpp
│ │ │ │ ├── double_buffer_transmitter.hpp
│ │ │ │ ├── eos.hpp
│ │ │ │ ├── event_based_scheduler.hpp
│ │ │ │ ├── extension.hpp
│ │ │ │ ├── extension_factory_helper.hpp
│ │ │ │ ├── gems/
│ │ │ │ │ ├── event_list/
│ │ │ │ │ │ ├── event_list.hpp
│ │ │ │ │ │ └── unique_event_list.hpp
│ │ │ │ │ ├── queue_thread/
│ │ │ │ │ │ └── queue_thread.hpp
│ │ │ │ │ ├── staging_queue/
│ │ │ │ │ │ ├── staging_queue.hpp
│ │ │ │ │ │ └── staging_queue_iterator.hpp
│ │ │ │ │ ├── suballocators/
│ │ │ │ │ │ ├── first_fit_allocator.hpp
│ │ │ │ │ │ └── first_fit_allocator_base.hpp
│ │ │ │ │ ├── timed_job_list/
│ │ │ │ │ │ └── timed_job_list.hpp
│ │ │ │ │ ├── utils/
│ │ │ │ │ │ └── time.hpp
│ │ │ │ │ └── video_buffer/
│ │ │ │ │ └── allocator.hpp
│ │ │ │ ├── graph_driver.hpp
│ │ │ │ ├── graph_driver_worker_common.hpp
│ │ │ │ ├── graph_worker.hpp
│ │ │ │ ├── greedy_scheduler.hpp
│ │ │ │ ├── ipc_client.hpp
│ │ │ │ ├── ipc_server.hpp
│ │ │ │ ├── memory_buffer.hpp
│ │ │ │ ├── metric.hpp
│ │ │ │ ├── monitor.hpp
│ │ │ │ ├── multi_thread_scheduler.hpp
│ │ │ │ ├── network_context.hpp
│ │ │ │ ├── new_component_allocator.hpp
│ │ │ │ ├── queue.hpp
│ │ │ │ ├── receiver.hpp
│ │ │ │ ├── resources.hpp
│ │ │ │ ├── scheduler.hpp
│ │ │ │ ├── scheduling_condition.hpp
│ │ │ │ ├── scheduling_term.hpp
│ │ │ │ ├── scheduling_term_combiner.hpp
│ │ │ │ ├── scheduling_terms.hpp
│ │ │ │ ├── system.hpp
│ │ │ │ ├── tensor.hpp
│ │ │ │ ├── timestamp.hpp
│ │ │ │ ├── topic.hpp
│ │ │ │ ├── transmitter.hpp
│ │ │ │ ├── unbounded_allocator.hpp
│ │ │ │ ├── vault.hpp
│ │ │ │ └── yaml_file_loader.hpp
│ │ │ ├── stream/
│ │ │ │ ├── stream_nvsci.hpp
│ │ │ │ ├── stream_nvscisync.hpp
│ │ │ │ ├── stream_sync_id.hpp
│ │ │ │ └── tests/
│ │ │ │ └── test_gxf_stream_sync_cuda_helper.hpp
│ │ │ └── ucx/
│ │ │ ├── ucx_common.hpp
│ │ │ ├── ucx_component_serializer.hpp
│ │ │ ├── ucx_context.hpp
│ │ │ ├── ucx_entity_serializer.hpp
│ │ │ ├── ucx_receiver.hpp
│ │ │ ├── ucx_serialization_buffer.hpp
│ │ │ └── ucx_transmitter.hpp
│ │ └── third_party/
│ │ └── LICENSE.txt
│ ├── package.xml
│ └── src/
│ └── isaac_ros_gxf.cpp
├── isaac_ros_gxf_extensions/
│ ├── gxf_isaac_argus/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_atlas/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── atlas/
│ │ │ ├── composite_schema_server.hpp
│ │ │ └── pose_tree_frame.hpp
│ │ └── package.xml
│ ├── gxf_isaac_camera_utils/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── camera_utils/
│ │ │ ├── camera_info_synchronizer.cpp
│ │ │ ├── camera_info_synchronizer.hpp
│ │ │ ├── camera_utils.cpp
│ │ │ ├── stereo_camera_synchronizer.cpp
│ │ │ └── stereo_camera_synchronizer.hpp
│ │ └── package.xml
│ ├── gxf_isaac_cuda/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_flatscan_localization/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_gems/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ ├── gems/
│ │ │ │ ├── algorithm/
│ │ │ │ │ └── string_utils.hpp
│ │ │ │ ├── common/
│ │ │ │ │ ├── composite_schema_uid.hpp
│ │ │ │ │ └── pose_frame_uid.hpp
│ │ │ │ ├── composite/
│ │ │ │ │ ├── composite_from_tensor.hpp
│ │ │ │ │ ├── composite_view.hpp
│ │ │ │ │ ├── measure.hpp
│ │ │ │ │ ├── quantity.hpp
│ │ │ │ │ ├── schema.hpp
│ │ │ │ │ └── schema_tensor_archive.hpp
│ │ │ │ ├── coms/
│ │ │ │ │ └── socket.hpp
│ │ │ │ ├── control_types/
│ │ │ │ │ └── differential_drive.hpp
│ │ │ │ ├── core/
│ │ │ │ │ ├── allocator/
│ │ │ │ │ │ ├── allocator_base.hpp
│ │ │ │ │ │ └── allocators.hpp
│ │ │ │ │ ├── assert.hpp
│ │ │ │ │ ├── buffers/
│ │ │ │ │ │ ├── algorithm.hpp
│ │ │ │ │ │ ├── buffer.hpp
│ │ │ │ │ │ └── traits.hpp
│ │ │ │ │ ├── byte.hpp
│ │ │ │ │ ├── constants.hpp
│ │ │ │ │ ├── epsilon.hpp
│ │ │ │ │ ├── image/
│ │ │ │ │ │ └── image.hpp
│ │ │ │ │ ├── logger.hpp
│ │ │ │ │ ├── math/
│ │ │ │ │ │ ├── macros.hpp
│ │ │ │ │ │ ├── pose2.hpp
│ │ │ │ │ │ ├── pose3.hpp
│ │ │ │ │ │ ├── so2.hpp
│ │ │ │ │ │ ├── so3.hpp
│ │ │ │ │ │ ├── types.hpp
│ │ │ │ │ │ └── utils.hpp
│ │ │ │ │ ├── optional.hpp
│ │ │ │ │ └── tensor/
│ │ │ │ │ ├── sample_cloud.hpp
│ │ │ │ │ └── tensor.hpp
│ │ │ │ ├── cuda_utils/
│ │ │ │ │ ├── launch_utils.hpp
│ │ │ │ │ ├── stride_pointer.hpp
│ │ │ │ │ ├── stride_pointer_3d.hpp
│ │ │ │ │ └── vector_math.hpp
│ │ │ │ ├── flatscan/
│ │ │ │ │ ├── flatscan_info.hpp
│ │ │ │ │ └── flatscan_types.hpp
│ │ │ │ ├── geometry/
│ │ │ │ │ ├── line.hpp
│ │ │ │ │ ├── line_segment.hpp
│ │ │ │ │ ├── line_utils.hpp
│ │ │ │ │ ├── n_cuboid.hpp
│ │ │ │ │ ├── n_sphere.hpp
│ │ │ │ │ ├── pinhole.hpp
│ │ │ │ │ ├── plane.hpp
│ │ │ │ │ ├── polygon.hpp
│ │ │ │ │ ├── polyline.hpp
│ │ │ │ │ └── types.hpp
│ │ │ │ ├── gxf_helpers/
│ │ │ │ │ ├── expected_macro_abstract.hpp
│ │ │ │ │ ├── expected_macro_common.hpp
│ │ │ │ │ ├── expected_macro_cuda.hpp
│ │ │ │ │ ├── expected_macro_gxf.hpp
│ │ │ │ │ ├── expected_macro_isaac.hpp
│ │ │ │ │ └── image_view.hpp
│ │ │ │ ├── image/
│ │ │ │ │ ├── color.hpp
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ └── utils.hpp
│ │ │ │ ├── pose_tree/
│ │ │ │ │ ├── pose_tree.hpp
│ │ │ │ │ └── pose_tree_edge_history.hpp
│ │ │ │ ├── serialization/
│ │ │ │ │ ├── base64.hpp
│ │ │ │ │ ├── json.hpp
│ │ │ │ │ └── json_formatter.hpp
│ │ │ │ ├── sight/
│ │ │ │ │ ├── sop.hpp
│ │ │ │ │ ├── sop_asset.hpp
│ │ │ │ │ ├── sop_image.hpp
│ │ │ │ │ ├── sop_mesh.hpp
│ │ │ │ │ ├── sop_point_cloud.hpp
│ │ │ │ │ ├── sop_style.hpp
│ │ │ │ │ ├── sop_text.hpp
│ │ │ │ │ └── sop_transform.hpp
│ │ │ │ ├── uuid/
│ │ │ │ │ └── uuid.hpp
│ │ │ │ └── video_buffer/
│ │ │ │ └── allocator.hpp
│ │ │ └── third_party/
│ │ │ └── nlohmann/
│ │ │ └── json.hpp
│ │ └── package.xml
│ ├── gxf_isaac_gxf_helpers/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── gxf_helpers/
│ │ │ ├── parameter_parser_isaac.hpp
│ │ │ ├── parameter_wrapper_isaac.hpp
│ │ │ └── string_provider.hpp
│ │ └── package.xml
│ ├── gxf_isaac_hesai/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_localization/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_message_compositor/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── message_compositor/
│ │ │ └── message_relay.hpp
│ │ └── package.xml
│ ├── gxf_isaac_messages/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── messages/
│ │ │ ├── accelerometer_message.hpp
│ │ │ ├── battery_state_message.hpp
│ │ │ ├── camera_message.hpp
│ │ │ ├── composite_message.hpp
│ │ │ ├── correlated_timestamp_message.hpp
│ │ │ ├── encoder_tick_message.hpp
│ │ │ ├── flatscan_message.hpp
│ │ │ ├── gyroscope_message.hpp
│ │ │ ├── helpers.hpp
│ │ │ ├── imu_message.hpp
│ │ │ ├── json_message.hpp
│ │ │ └── pose3d_cov_message.hpp
│ │ └── package.xml
│ ├── gxf_isaac_messages_throttler/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_optimizer/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── extensions/
│ │ │ └── gxf_optimizer/
│ │ │ ├── common/
│ │ │ │ └── type.hpp
│ │ │ ├── core/
│ │ │ │ └── optimizer.hpp
│ │ │ └── exporter/
│ │ │ └── graph_types.hpp
│ │ └── package.xml
│ ├── gxf_isaac_point_cloud/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_range_scan_processing/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_ros_cuda/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_ros_messages/
│ │ ├── CMakeLists.txt
│ │ ├── gxf/
│ │ │ └── messages/
│ │ │ ├── flat_scan_message.hpp
│ │ │ └── point_cloud_message.hpp
│ │ └── package.xml
│ ├── gxf_isaac_segway/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_sight/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ ├── gxf_isaac_timestamp_correlator/
│ │ ├── CMakeLists.txt
│ │ └── package.xml
│ └── gxf_isaac_utils/
│ ├── CMakeLists.txt
│ ├── gxf/
│ │ └── extensions/
│ │ └── utils/
│ │ ├── disparity_to_depth.cpp
│ │ ├── disparity_to_depth.cu.cpp
│ │ ├── disparity_to_depth.cu.hpp
│ │ ├── disparity_to_depth.hpp
│ │ ├── image_loader.cpp
│ │ ├── image_loader.hpp
│ │ ├── udp_receiver.cpp
│ │ ├── udp_receiver.hpp
│ │ └── utils.cpp
│ └── package.xml
├── isaac_ros_managed_nitros/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── isaac_ros_managed_nitros/
│ │ ├── managed_nitros_message_filters_subscriber.hpp
│ │ ├── managed_nitros_publisher.hpp
│ │ └── managed_nitros_subscriber.hpp
│ └── package.xml
├── isaac_ros_managed_nitros_examples/
│ ├── custom_nitros_dnn_image_encoder/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── custom_nitros_dnn_image_encoder/
│ │ │ └── image_encoder_node.hpp
│ │ ├── launch/
│ │ │ └── custom_image_isaac_ros_dope_tensor_rt.launch.py
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── image_encoder_node.cpp
│ │ └── test/
│ │ ├── custom_nitros_dnn_image_encoder_pol.py
│ │ └── test_cases/
│ │ └── profile_image/
│ │ └── image.json
│ ├── custom_nitros_image/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── custom_nitros_image/
│ │ │ ├── gpu_image_builder_node.hpp
│ │ │ ├── gpu_image_viewer_node.hpp
│ │ │ └── nitros_image_switch_node.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── gpu_image_builder_node.cpp
│ │ │ ├── gpu_image_viewer_node.cpp
│ │ │ └── nitros_image_switch_node.cpp
│ │ └── test/
│ │ ├── custom_nitros_image_builder_pol.py
│ │ ├── custom_nitros_image_pol.py
│ │ ├── custom_nitros_image_viewer_pol.py
│ │ ├── test_cases/
│ │ │ └── profile_image/
│ │ │ └── image.json
│ │ └── test_nitros_image_switch_pol.py
│ ├── custom_nitros_message_filter/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── custom_nitros_message_filter/
│ │ │ └── synchronizer_node.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── synchronizer_node.cpp
│ │ └── test/
│ │ ├── custom_nitros_message_filter_pol.py
│ │ └── test_cases/
│ │ └── profile_image/
│ │ ├── camera_info.json
│ │ └── image.json
│ ├── custom_nitros_message_filter_interfaces/
│ │ ├── CMakeLists.txt
│ │ ├── msg/
│ │ │ └── SyncStatus.msg
│ │ └── package.xml
│ └── custom_nitros_string/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── custom_nitros_string/
│ │ ├── string_decoder_node.hpp
│ │ └── string_encoder_node.hpp
│ ├── package.xml
│ ├── src/
│ │ ├── string_decoder_node.cpp
│ │ └── string_encoder_node.cpp
│ └── test/
│ ├── custom_nitros_string_decoder_pol.py
│ ├── custom_nitros_string_encoder_pol.py
│ └── custom_nitros_string_pol.py
├── isaac_ros_nitros/
│ ├── CMakeLists.txt
│ ├── config/
│ │ └── type_adapter_nitros_context_graph.yaml
│ ├── include/
│ │ └── isaac_ros_nitros/
│ │ ├── nitros_context.hpp
│ │ ├── nitros_node.hpp
│ │ ├── nitros_publisher.hpp
│ │ ├── nitros_publisher_subscriber_base.hpp
│ │ ├── nitros_publisher_subscriber_group.hpp
│ │ ├── nitros_subscriber.hpp
│ │ └── types/
│ │ ├── nitros_empty.hpp
│ │ ├── nitros_format_agent.hpp
│ │ ├── nitros_type_base.hpp
│ │ ├── nitros_type_manager.hpp
│ │ ├── nitros_type_message_filter_traits.hpp
│ │ ├── nitros_type_view_factory.hpp
│ │ ├── type_adapter_nitros_context.hpp
│ │ └── type_utility.hpp
│ ├── lib/
│ │ ├── AMENT_IGNORE
│ │ ├── cuapriltags/
│ │ │ ├── cuapriltags/
│ │ │ │ └── cuAprilTags.h
│ │ │ ├── lib_aarch64_jetpack51/
│ │ │ │ └── libcuapriltags.a
│ │ │ ├── lib_aarch64_jetpack61/
│ │ │ │ └── libcuapriltags.a
│ │ │ └── lib_x86_64_cuda_12_6/
│ │ │ └── libcuapriltags.a
│ │ ├── cumotion/
│ │ │ ├── .gitattributes
│ │ │ ├── aarch64_jetpack70/
│ │ │ │ ├── LICENSE
│ │ │ │ ├── NOTICE
│ │ │ │ ├── include/
│ │ │ │ │ └── cumotion/
│ │ │ │ │ ├── collision_free_ik_solver.h
│ │ │ │ │ ├── collision_sphere_generator.h
│ │ │ │ │ ├── composite_path_spec.h
│ │ │ │ │ ├── cspace_path.h
│ │ │ │ │ ├── cspace_path_spec.h
│ │ │ │ │ ├── cumotion.h
│ │ │ │ │ ├── cumotion_export.h
│ │ │ │ │ ├── ik_solver.h
│ │ │ │ │ ├── kinematics.h
│ │ │ │ │ ├── linear_cspace_path.h
│ │ │ │ │ ├── motion_planner.h
│ │ │ │ │ ├── obstacle.h
│ │ │ │ │ ├── path_conversion.h
│ │ │ │ │ ├── path_spec_yaml.h
│ │ │ │ │ ├── pose3.h
│ │ │ │ │ ├── rmpflow.h
│ │ │ │ │ ├── robot_description.h
│ │ │ │ │ ├── robot_segmenter.h
│ │ │ │ │ ├── robot_world_inspector.h
│ │ │ │ │ ├── rotation3.h
│ │ │ │ │ ├── task_space_path.h
│ │ │ │ │ ├── task_space_path_spec.h
│ │ │ │ │ ├── text_style.h
│ │ │ │ │ ├── trajectory.h
│ │ │ │ │ ├── trajectory_generator.h
│ │ │ │ │ ├── trajectory_optimizer.h
│ │ │ │ │ ├── version.h
│ │ │ │ │ ├── vision.h
│ │ │ │ │ ├── world.h
│ │ │ │ │ └── world_inspector.h
│ │ │ │ ├── lib/
│ │ │ │ │ ├── cmake/
│ │ │ │ │ │ └── cumotion/
│ │ │ │ │ │ ├── cumotionConfig.cmake
│ │ │ │ │ │ ├── cumotionConfigVersion.cmake
│ │ │ │ │ │ ├── cumotionTargets-release.cmake
│ │ │ │ │ │ └── cumotionTargets.cmake
│ │ │ │ │ └── libcumotion.so.1.1.0
│ │ │ │ └── python_wheels/
│ │ │ │ ├── cumotion-1.1.0-cp312-cp312-linux_aarch64.whl
│ │ │ │ └── cumotion_vis-1.1.0-py3-none-any.whl
│ │ │ └── x86_64_cuda_13_0/
│ │ │ ├── LICENSE
│ │ │ ├── NOTICE
│ │ │ ├── include/
│ │ │ │ └── cumotion/
│ │ │ │ ├── collision_free_ik_solver.h
│ │ │ │ ├── collision_sphere_generator.h
│ │ │ │ ├── composite_path_spec.h
│ │ │ │ ├── cspace_path.h
│ │ │ │ ├── cspace_path_spec.h
│ │ │ │ ├── cumotion.h
│ │ │ │ ├── cumotion_export.h
│ │ │ │ ├── ik_solver.h
│ │ │ │ ├── kinematics.h
│ │ │ │ ├── linear_cspace_path.h
│ │ │ │ ├── motion_planner.h
│ │ │ │ ├── obstacle.h
│ │ │ │ ├── path_conversion.h
│ │ │ │ ├── path_spec_yaml.h
│ │ │ │ ├── pose3.h
│ │ │ │ ├── rmpflow.h
│ │ │ │ ├── robot_description.h
│ │ │ │ ├── robot_segmenter.h
│ │ │ │ ├── robot_world_inspector.h
│ │ │ │ ├── rotation3.h
│ │ │ │ ├── task_space_path.h
│ │ │ │ ├── task_space_path_spec.h
│ │ │ │ ├── text_style.h
│ │ │ │ ├── trajectory.h
│ │ │ │ ├── trajectory_generator.h
│ │ │ │ ├── trajectory_optimizer.h
│ │ │ │ ├── version.h
│ │ │ │ ├── vision.h
│ │ │ │ ├── world.h
│ │ │ │ └── world_inspector.h
│ │ │ ├── lib/
│ │ │ │ ├── cmake/
│ │ │ │ │ └── cumotion/
│ │ │ │ │ ├── cumotionConfig.cmake
│ │ │ │ │ ├── cumotionConfigVersion.cmake
│ │ │ │ │ ├── cumotionTargets-release.cmake
│ │ │ │ │ └── cumotionTargets.cmake
│ │ │ │ └── libcumotion.so.1.1.0
│ │ │ └── python_wheels/
│ │ │ ├── cumotion-1.1.0-cp312-cp312-linux_x86_64.whl
│ │ │ └── cumotion_vis-1.1.0-py3-none-any.whl
│ │ └── cuvslam/
│ │ ├── .gitattributes
│ │ ├── include/
│ │ │ └── cuvslam/
│ │ │ ├── cuvslam.h
│ │ │ ├── cuvslam2.h
│ │ │ ├── ground_constraint.h
│ │ │ └── ground_constraint2.h
│ │ ├── lib_aarch64_jetpack61/
│ │ │ └── cuvslam_api_launcher
│ │ ├── lib_aarch64_jetpack70/
│ │ │ └── cuvslam_api_launcher
│ │ ├── lib_x86_64_cuda_12_6/
│ │ │ └── cuvslam_api_launcher
│ │ └── lib_x86_64_cuda_13_0/
│ │ └── cuvslam_api_launcher
│ ├── package.xml
│ ├── scripts/
│ │ └── diagnostic_viewer.py
│ ├── src/
│ │ ├── nitros_context.cpp
│ │ ├── nitros_node.cpp
│ │ ├── nitros_publisher.cpp
│ │ ├── nitros_publisher_subscriber_group.cpp
│ │ ├── nitros_subscriber.cpp
│ │ └── types/
│ │ ├── nitros_empty.cpp
│ │ ├── nitros_type_base.cpp
│ │ └── type_adapter_nitros_context.cpp
│ └── test/
│ ├── config/
│ │ └── test_forward_node.yaml
│ ├── isaac_ros_nitros_diagnostics_test_pol.py
│ ├── isaac_ros_nitros_multi_node_test_pol.py
│ ├── isaac_ros_nitros_test_pol.py
│ ├── src/
│ │ └── nitros_empty_forward_node.cpp
│ └── test_cases/
│ └── nitros_image/
│ └── profile/
│ ├── april_tag_detection_array.json
│ ├── camera_info.json
│ ├── image.json
│ └── ketchup.pcd
├── isaac_ros_nitros_bridge/
│ ├── .gitattributes
│ ├── .gitignore
│ ├── CONTRIBUTING.md
│ ├── LICENSE
│ ├── config/
│ │ ├── nitros_bridge_convert_forward.yaml
│ │ ├── nitros_bridge_forward.yaml
│ │ └── nitros_bridge_image_converter.yaml
│ ├── isaac_ros_nitros_bridge_ros2/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_bridge_ros2/
│ │ │ ├── image_converter_node.hpp
│ │ │ ├── ipc_buffer_manager.hpp
│ │ │ └── tensor_list_converter_node.hpp
│ │ ├── launch/
│ │ │ ├── isaac_ros_nitros_bridge_image_converter.launch.py
│ │ │ ├── isaac_ros_nitros_bridge_quickstart.launch.py
│ │ │ └── isaac_ros_nitros_bridge_tensor_list_converter.launch.py
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── image_converter_node.cpp
│ │ │ └── tensor_list_converter_node.cpp
│ │ └── test/
│ │ ├── isaac_ros_nitros_bridge_image_pol.py
│ │ ├── isaac_ros_nitros_bridge_tensor_list_pol.py
│ │ └── test_cases/
│ │ └── nitros_image/
│ │ └── profile/
│ │ └── image.json
│ ├── resources/
│ │ ├── quickstart.bag/
│ │ │ ├── metadata.yaml
│ │ │ ├── quickstart.bag_0.db3
│ │ │ └── quickstart.bag_0.db3.zstd
│ │ └── unet_sample_data_ros1.bag
│ └── scripts/
│ └── workspace-entrypoint.sh
├── isaac_ros_nitros_topic_tools/
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── isaac_ros_nitros_topic_tools/
│ │ ├── isaac_ros_nitros_camera_drop_node.hpp
│ │ └── isaac_ros_nitros_topic_tools_common.hpp
│ ├── launch/
│ │ └── isaac_ros_nitros_camera_drop.launch.py
│ ├── package.xml
│ ├── src/
│ │ └── isaac_ros_nitros_camera_drop_node.cpp
│ └── test/
│ ├── isaac_ros_nitros_topic_tools_camera_drop_node_mode_0_test.py
│ ├── isaac_ros_nitros_topic_tools_camera_drop_node_mode_1_test.py
│ └── isaac_ros_nitros_topic_tools_camera_drop_node_mode_2_test.py
├── isaac_ros_nitros_type/
│ ├── isaac_ros_nitros_battery_state_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_battery_state_type/
│ │ │ └── nitros_battery_state.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_battery_state.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_battery_state_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_battery_state_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_battery_state/
│ │ └── profile/
│ │ └── battery_state.json
│ ├── isaac_ros_nitros_camera_info_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_camera_info_type/
│ │ │ ├── nitros_camera_info.hpp
│ │ │ └── nitros_camera_info_view.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_camera_info.cpp
│ │ │ └── nitros_camera_info_view.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_camera_info_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_camera_info_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_camera_info/
│ │ └── profile/
│ │ └── camera_info.json
│ ├── isaac_ros_nitros_compressed_image_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_compressed_image_type/
│ │ │ └── nitros_compressed_image.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_compressed_image.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_compressed_image_type_test_pol.py
│ │ └── src/
│ │ └── nitros_compressed_image_forward_node.cpp
│ ├── isaac_ros_nitros_compressed_video_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_compressed_video_type/
│ │ │ └── nitros_compressed_video.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_compressed_video.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_compressed_video_type_test_pol.py
│ │ └── src/
│ │ └── nitros_compressed_video_forward_node.cpp
│ ├── isaac_ros_nitros_correlated_timestamp_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_correlated_timestamp_type/
│ │ │ └── nitros_correlated_timestamp.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_correlated_timestamp.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_correlated_timestamp_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_correlated_timestamp_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_correlated_timestamp/
│ │ └── profile/
│ │ └── correlated_timestamp.json
│ ├── isaac_ros_nitros_detection2_d_array_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ ├── detectnet/
│ │ │ │ ├── detection2_d.hpp
│ │ │ │ └── detection2_d_array_message.hpp
│ │ │ └── isaac_ros_nitros_detection2_d_array_type/
│ │ │ └── nitros_detection2_d_array.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── detection2_d_array_message.cpp
│ │ │ └── nitros_detection2_d_array.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_detection2_d_array_type_test_pol.py
│ │ ├── src/
│ │ │ ├── detection2_d_test_ext.cpp
│ │ │ └── nitros_detection2_d_array_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_detection2_d_array/
│ │ └── profile/
│ │ └── nitros_detection2_d_array.json
│ ├── isaac_ros_nitros_detection3_d_array_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ ├── detection3_d_array_message/
│ │ │ │ └── detection3_d_array_message.hpp
│ │ │ └── isaac_ros_nitros_detection3_d_array_type/
│ │ │ └── nitros_detection3_d_array.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── detection3_d_array_message.cpp
│ │ │ └── nitros_detection3_d_array.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_detection3_d_array_type_test_pol.py
│ │ ├── src/
│ │ │ ├── detection3_d_test_ext.cpp
│ │ │ └── nitros_detection3_d_array_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_detection3_d_array/
│ │ └── profile/
│ │ └── nitros_detection3_d_array.json
│ ├── isaac_ros_nitros_disparity_image_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_disparity_image_type/
│ │ │ ├── nitros_disparity_image.hpp
│ │ │ └── nitros_disparity_image_builder.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_disparity_image.cpp
│ │ │ └── nitros_disparity_image_builder.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_disparity_image_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_disparity_image_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_disparity_image/
│ │ └── profile/
│ │ └── image.json
│ ├── isaac_ros_nitros_encoder_ticks_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_encoder_ticks_type/
│ │ │ └── nitros_encoder_ticks.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_encoder_ticks.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_encoder_ticks_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_encoder_ticks_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_encoder_ticks/
│ │ └── profile/
│ │ └── encoder_ticks.json
│ ├── isaac_ros_nitros_flat_scan_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_flat_scan_type/
│ │ │ └── nitros_flat_scan.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_flat_scan.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_flat_scan_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_flat_scan_forward_node.cpp
│ │ └── test_cases/
│ │ └── profile/
│ │ └── flat_scan.json
│ ├── isaac_ros_nitros_image_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_image_type/
│ │ │ ├── nitros_image.hpp
│ │ │ ├── nitros_image_builder.hpp
│ │ │ ├── nitros_image_details.hpp
│ │ │ └── nitros_image_view.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_image.cpp
│ │ │ ├── nitros_image_builder.cpp
│ │ │ └── nitros_image_view.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_image_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_image_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_image/
│ │ └── profile/
│ │ └── image.json
│ ├── isaac_ros_nitros_imu_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_imu_type/
│ │ │ └── nitros_imu.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_imu.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_imu_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_imu_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_imu/
│ │ └── profile/
│ │ └── imu.json
│ ├── isaac_ros_nitros_occupancy_grid_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_occupancy_grid_type/
│ │ │ └── nitros_occupancy_grid.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_occupancy_grid.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_occupancy_grid_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_occupancy_grid_forward_node.cpp
│ │ └── test_cases/
│ │ └── profile/
│ │ └── occupancy_grid.json
│ ├── isaac_ros_nitros_odometry_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_odometry_type/
│ │ │ └── nitros_odometry.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_odometry.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_odometry_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_odometry_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_odometry/
│ │ └── profile/
│ │ └── odometry.json
│ ├── isaac_ros_nitros_point_cloud_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_point_cloud_type/
│ │ │ ├── nitros_point_cloud.hpp
│ │ │ ├── nitros_point_cloud_builder.hpp
│ │ │ └── nitros_point_cloud_view.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_point_cloud.cpp
│ │ │ ├── nitros_point_cloud_builder.cpp
│ │ │ └── nitros_point_cloud_view.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_managed_nitros_point_cloud_type_test_pol.py
│ │ ├── isaac_ros_nitros_point_cloud_type_test_pol.py
│ │ ├── managed_nitros_point_cloud_forward_node.cpp
│ │ ├── src/
│ │ │ └── nitros_point_cloud_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_point_cloud/
│ │ └── profile/
│ │ └── ketchup.pcd
│ ├── isaac_ros_nitros_pose_array_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_pose_array_type/
│ │ │ └── nitros_pose_array.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_pose_array.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_pose_array_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_pose_array_forward_node.cpp
│ │ └── test_cases/
│ │ └── profile/
│ │ └── pose_array.json
│ ├── isaac_ros_nitros_pose_cov_stamped_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_pose_cov_stamped_type/
│ │ │ └── nitros_pose_cov_stamped.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_pose_cov_stamped.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_pose_cov_stamped_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_pose_cov_stamped_forward_node.cpp
│ │ └── test_cases/
│ │ └── nitros_pose_cov_stamped/
│ │ └── profile/
│ │ └── pose_cov_stamped.json
│ ├── isaac_ros_nitros_std_msg_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_std_msg_type/
│ │ │ └── nitros_int64.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ └── nitros_int64.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_int64_type_test_pol.py
│ │ ├── src/
│ │ │ └── nitros_int64_forward_node.cpp
│ │ └── test_cases/
│ │ └── profile/
│ │ └── pose_array.json
│ ├── isaac_ros_nitros_tensor_list_type/
│ │ ├── CMakeLists.txt
│ │ ├── include/
│ │ │ └── isaac_ros_nitros_tensor_list_type/
│ │ │ ├── nitros_data_type.hpp
│ │ │ ├── nitros_tensor.hpp
│ │ │ ├── nitros_tensor_builder.hpp
│ │ │ ├── nitros_tensor_list.hpp
│ │ │ ├── nitros_tensor_list_builder.hpp
│ │ │ ├── nitros_tensor_list_view.hpp
│ │ │ └── nitros_tensor_shape.hpp
│ │ ├── package.xml
│ │ ├── src/
│ │ │ ├── nitros_data_type.cpp
│ │ │ ├── nitros_tensor_builder.cpp
│ │ │ ├── nitros_tensor_list.cpp
│ │ │ ├── nitros_tensor_list_builder.cpp
│ │ │ └── nitros_tensor_list_view.cpp
│ │ └── test/
│ │ ├── config/
│ │ │ └── test_forward_node.yaml
│ │ ├── isaac_ros_nitros_tensor_list_type_test_pol.py
│ │ └── src/
│ │ └── nitros_tensor_list_forward_node.cpp
│ └── isaac_ros_nitros_twist_type/
│ ├── .vscode/
│ │ └── settings.json
│ ├── CMakeLists.txt
│ ├── include/
│ │ └── isaac_ros_nitros_twist_type/
│ │ └── nitros_twist.hpp
│ ├── package.xml
│ ├── src/
│ │ └── nitros_twist.cpp
│ └── test/
│ ├── config/
│ │ └── test_forward_node.yaml
│ ├── isaac_ros_nitros_twist_type_test_pol.py
│ ├── src/
│ │ └── nitros_twist_forward_node.cpp
│ └── test_cases/
│ └── nitros_twist/
│ └── profile/
│ └── twist.json
└── isaac_ros_pynitros/
├── isaac_ros_pynitros/
│ ├── __init__.py
│ ├── examples/
│ │ ├── __init__.py
│ │ ├── pynitros_dnn_image_encoder_node.py
│ │ ├── pynitros_image_forward_node.py
│ │ ├── pynitros_message_filter_sync_node.py
│ │ ├── pynitros_point_cloud_forward_node.py
│ │ └── pynitros_tensor_list_forward_node.py
│ ├── isaac_ros_pynitros_message_filter.py
│ ├── isaac_ros_pynitros_publisher.py
│ ├── isaac_ros_pynitros_subscriber.py
│ ├── pynitros_type_builders/
│ │ ├── __init__.py
│ │ ├── pynitros_image_builder.py
│ │ ├── pynitros_point_cloud_builder.py
│ │ ├── pynitros_tensor_list_builder.py
│ │ └── pynitros_type_builder_base.py
│ ├── pynitros_type_views/
│ │ ├── __init__.py
│ │ ├── pynitros_image_view.py
│ │ ├── pynitros_point_cloud_view.py
│ │ ├── pynitros_tensor_list_view.py
│ │ └── pynitros_type_view_base.py
│ └── utils/
│ ├── __init__.py
│ ├── cpu_shared_mem.py
│ └── tensor_data_type.py
├── launch/
│ ├── isaac_ros_pynitros_dnn_image_encoder.launch.py
│ ├── isaac_ros_pynitros_quickstart.launch.py
│ └── isaac_ros_pynitros_to_nitros.launch.py
├── package.xml
├── resource/
│ └── isaac_ros_pynitros
├── setup.cfg
├── setup.py
└── test/
├── isaac_ros_pynitros_dnn_image_encoder.py
├── isaac_ros_pynitros_image_test.py
├── isaac_ros_pynitros_point_cloud_test.py
├── isaac_ros_pynitros_sync_test.py
├── isaac_ros_pynitros_tensor_list_test.py
├── test_cases/
│ ├── nitros_image/
│ │ └── profile/
│ │ └── image.json
│ └── nitros_point_cloud/
│ └── test_data/
│ └── ketchup.pcd
├── test_copyright.py
├── test_flake8.py
└── test_pep257.py
Showing preview only (461K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (4971 symbols across 525 files)
FILE: isaac_ros_gxf/gxf/core/include/common/byte.hpp
type std (line 21) | namespace std {
type nvidia (line 26) | namespace nvidia {
FILE: isaac_ros_gxf/gxf/core/include/common/endian.hpp
type nvidia (line 28) | namespace nvidia {
function IsLittleEndian (line 32) | inline bool IsLittleEndian() {
function T (line 40) | inline T EncodeLittleEndian(T value) {
function T (line 54) | inline T DecodeLittleEndian(T value) {
function IsBigEndian (line 67) | inline bool IsBigEndian() {
function T (line 75) | inline T EncodeBigEndian(T value) {
function T (line 89) | inline T DecodeBigEndian(T value) {
FILE: isaac_ros_gxf/gxf/core/include/common/expected.hpp
type nvidia (line 27) | namespace nvidia {
type Unexpected_t (line 29) | struct Unexpected_t
class Expected (line 30) | class Expected
method Expected (line 778) | constexpr Expected(T&& value) : detail::ExpectedBase<T, E, Expected>...
method Expected (line 781) | constexpr Expected(U&& value) : detail::ExpectedBase<T, E, Expected>...
method Expected (line 784) | explicit constexpr Expected(U&& value)
method Expected (line 788) | explicit constexpr Expected(Args&&... args)
method Expected (line 792) | constexpr Expected(const Expected<U, E>& other) {
method Expected (line 797) | explicit constexpr Expected(const Expected<U, E>& other) {
method Expected (line 802) | constexpr Expected(Expected<U, E>&& other) {
method Expected (line 808) | explicit constexpr Expected(Expected<U, E>&& other) {
method Expected (line 814) | constexpr Expected& operator=(U&& value) {
method T (line 821) | T& replace(Args&&... args) {
method T (line 829) | constexpr const T& value() const& {
method T (line 834) | constexpr T& value() & {
method T (line 839) | constexpr const T&& value() const&& {
method T (line 844) | constexpr T&& value() && {
type detail (line 35) | namespace detail {
type IsExpectedHelper (line 38) | struct IsExpectedHelper : FalseType {}
type IsExpectedHelper<Expected<T, E>> (line 41) | struct IsExpectedHelper<Expected<T, E>> : TrueType {}
type ErrorTypeHelper (line 51) | struct ErrorTypeHelper : TypeIdentity<void> {}
type ValueTypeHelper (line 64) | struct ValueTypeHelper {}
type ValueTypeHelper<Expected<T, E>> (line 67) | struct ValueTypeHelper<Expected<T, E>> { using type = T; }
type UnexpectedTypeHelper (line 74) | struct UnexpectedTypeHelper : TypeIdentity<T> {}
type UnexpectedTypeHelper<Unexpected<T>> (line 77) | struct UnexpectedTypeHelper<Unexpected<T>> : TypeIdentity<T> {}
type Unit (line 95) | struct Unit { byte dummy; }
type FlattenExpectedHelper (line 99) | struct FlattenExpectedHelper : TypeIdentity<Expected<T, E>> {}
type FlattenExpectedHelper<Expected<T, E>, E> (line 102) | struct FlattenExpectedHelper<Expected<T, E>, E> : TypeIdentity<Expec...
type FlattenExpectedHelper<Expected<T, E>&, E> (line 105) | struct FlattenExpectedHelper<Expected<T, E>&, E>
type FlattenExpectedHelper<const Expected<T, E>&, E> (line 109) | struct FlattenExpectedHelper<const Expected<T, E>&, E>
type Pack (line 116) | struct Pack {}
type IsCallableHelper (line 120) | struct IsCallableHelper : FalseType {}
type IsCallable (line 126) | struct IsCallable : IsCallableHelper<F, Pack<Es...>> {}
type IsErrorCallableHelper (line 133) | struct IsErrorCallableHelper : FalseType {}
type IsErrorCallable (line 139) | struct IsErrorCallable : IsErrorCallableHelper<F, Pack<Es...>> {}
function FunctorMap (line 147) | auto FunctorMap(F&& func, Args&&... expected) ->
function FunctorMap (line 155) | auto FunctorMap(F&& func, Args&&... expected) ->
function FunctorMapError (line 164) | Expected<ValueType<E>, ErrorResultType<F, E>> FunctorMapError(F&& fu...
function FunctorMapError (line 170) | Expected<T, ErrorResultType<F>> FunctorMapError(F&& func) {
class ExpectedBase (line 178) | class ExpectedBase {
method ExpectedBase (line 206) | constexpr ExpectedBase(const ExpectedBase& other) { constructFrom(...
method ExpectedBase (line 207) | constexpr ExpectedBase(ExpectedBase&& other) { constructFrom(std::...
method ExpectedBase (line 211) | explicit constexpr ExpectedBase(const ExpectedBase<T, G, C>& other) {
method ExpectedBase (line 218) | explicit constexpr ExpectedBase(ExpectedBase<T, G, C>&& other) {
method ExpectedBase (line 225) | constexpr ExpectedBase(const Unexpected<G>& error, const char* err...
method ExpectedBase (line 233) | constexpr ExpectedBase(Unexpected<G>&& error, const char* error_me...
method ExpectedBase (line 248) | ExpectedBase& operator=(const ExpectedBase& other) {
method ExpectedBase (line 254) | ExpectedBase& operator=(ExpectedBase&& other) {
method ExpectedBase (line 261) | ExpectedBase& operator=(const Unexpected<G>& error) {
method ExpectedBase (line 269) | ExpectedBase& operator=(Unexpected<G>&& error) {
method V (line 302) | constexpr V value_or(U&& default_value) const& {
method V (line 307) | constexpr V value_or(U&& default_value) && {
method has_value (line 311) | constexpr bool has_value() const { return !is_error_; }
method E (line 314) | constexpr const E& error() const& { return unexpected().value(); }
method E (line 315) | constexpr E& error() & { return unexpected().value(); }
method E (line 316) | constexpr E&& error() && { return std::move(unexpected()...
method Derived (line 328) | constexpr const Derived& log_error(Args&&... args) const& {
method Derived (line 333) | constexpr Derived& log_error(Args&&... args) & {
method Derived (line 338) | constexpr Derived&& log_error(Args&&... args) && {
method Derived (line 350) | constexpr const Derived& log_warning(Args&&... args) const& {
method Derived (line 355) | constexpr Derived& log_warning(Args&&... args) & {
method Derived (line 360) | constexpr Derived&& log_warning(Args&&... args) && {
method Derived (line 366) | constexpr const Derived& log_info(Args&&... args) const& {
method Derived (line 371) | constexpr Derived& log_info(Args&&... args) & {
method Derived (line 376) | constexpr Derived&& log_info(Args&&... args) && {
method Derived (line 382) | constexpr const Derived& log_debug(Args&&... args) const& {
method Derived (line 387) | constexpr Derived& log_debug(Args&&... args) & {
method Derived (line 392) | constexpr Derived&& log_debug(Args&&... args) && {
method substitute (line 403) | constexpr FlattenExpected<U, E> substitute(U next) const& {
method substitute (line 408) | constexpr FlattenExpected<U, E> substitute(U next) && {
method substitute_error (line 416) | constexpr Expected<ValueType<Derived>, G> substitute_error(G new_e...
method substitute_error (line 422) | constexpr Expected<ValueType<Derived>, G> substitute_error(G new_e...
method map (line 433) | constexpr EnableIfMappable_t<F, Derived&> map(F&& func) & {
method map (line 438) | constexpr EnableIfMappable_t<F, const Derived&> map(F&& func) cons...
method map (line 443) | constexpr EnableIfMappable_t<F, Derived&&> map(F&& func) && {
method map_error (line 454) | constexpr EnableIfMappableError_t<F, Derived&> map_error(F&& func)...
method map_error (line 461) | constexpr EnableIfMappableError_t<F, const Derived&> map_error(F&&...
method map_error (line 468) | constexpr EnableIfMappableError_t<F, Derived&&> map_error(F&& func...
method map (line 480) | constexpr EnableIfNonaryMappable_t<F, const Derived&> map(F&& func...
method map (line 485) | constexpr EnableIfNonaryMappable_t<F, const Derived&&> map(F&& fun...
method and_then (line 490) | constexpr FlattenExpected<ResultType<F>, E> and_then(F&& func) con...
method and_then (line 494) | constexpr FlattenExpected<ResultType<F>, E> and_then(F&& func) && {
method map_error (line 504) | constexpr EnableIfNonaryMappableError_t<F, const Derived&> map_err...
method map_error (line 512) | constexpr EnableIfNonaryMappableError_t<F, const Derived&&> map_er...
method and_then_error (line 519) | constexpr Expected<ValueType<Derived>, ErrorResultType<F>> and_the...
method and_then_error (line 525) | constexpr Expected<ValueType<Derived>, ErrorResultType<F>> and_the...
method map (line 535) | constexpr FlattenExpected<R&, E> map(R U::* ptr) & {
method map (line 545) | constexpr FlattenExpected<const R&, E> map(R U::* ptr) const& {
method map (line 553) | constexpr FlattenExpected<Decay_t<R>, E> map(R U::* ptr) && {
method map (line 564) | constexpr FlattenExpected<Decay_t<R>, E> map(R U::* ptr) const&& {
method map (line 575) | constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...), Args&&....
method map (line 583) | constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) & , Args...
method map (line 591) | constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) &&, Args...
method map (line 599) | constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) const, A...
method map (line 607) | constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) const&, ...
method map (line 615) | constexpr FlattenExpected<R, E> map(R (U::* ptr)(Args...) const&&,...
method assign_to (line 627) | constexpr Expected<void, E> assign_to(U& value) const& {
method assign_to (line 635) | constexpr Expected<void, E> assign_to(U& value) && {
method guard (line 647) | constexpr Expected<ValueType<Derived>, E> guard(P&& pred, E&& new_...
method guard (line 653) | constexpr Expected<ValueType<Derived>, E> guard(P&& pred, E&& new_...
method ignore_error (line 663) | constexpr Expected<ValueType<Derived>, E> ignore_error(U&& next) c...
method ignore_error (line 668) | constexpr Expected<ValueType<Derived>, E> ignore_error(U&& next) && {
method ignore_error (line 672) | constexpr Expected<void, E> ignore_error() const { return {}; }
method ExpectedBase (line 680) | ExpectedBase() = default;
method ExpectedBase (line 684) | constexpr ExpectedBase(Args&&... args) {
method Derived (line 705) | constexpr const Derived* derived() const { return static_cast<cons...
method Derived (line 706) | constexpr Derived* derived() { return static_cast<Deri...
method constructFrom (line 713) | constexpr void constructFrom(const ExpectedBase<U, G, D>& other) {
method constructFrom (line 719) | constexpr void constructFrom(ExpectedBase<U, G, D>&& other) {
method constructErrorFrom (line 724) | constexpr void constructErrorFrom(const ExpectedBase<U, G, D>& oth...
method constructErrorFrom (line 730) | constexpr void constructErrorFrom(ExpectedBase<U, G, D>&& other) {
method constructValueFrom (line 736) | constexpr void constructValueFrom(const ExpectedBase<U, G, D>& oth...
method constructValueFrom (line 742) | constexpr void constructValueFrom(ExpectedBase<U, G, D>&& other) {
method constructValueFrom (line 748) | void constructValueFrom(Args&&... args) {
method destruct (line 754) | constexpr void destruct() {
class Expected (line 773) | class Expected : public detail::ExpectedBase<T, E, Expected<T, E>> {
method Expected (line 778) | constexpr Expected(T&& value) : detail::ExpectedBase<T, E, Expected>...
method Expected (line 781) | constexpr Expected(U&& value) : detail::ExpectedBase<T, E, Expected>...
method Expected (line 784) | explicit constexpr Expected(U&& value)
method Expected (line 788) | explicit constexpr Expected(Args&&... args)
method Expected (line 792) | constexpr Expected(const Expected<U, E>& other) {
method Expected (line 797) | explicit constexpr Expected(const Expected<U, E>& other) {
method Expected (line 802) | constexpr Expected(Expected<U, E>&& other) {
method Expected (line 808) | explicit constexpr Expected(Expected<U, E>&& other) {
method Expected (line 814) | constexpr Expected& operator=(U&& value) {
method T (line 821) | T& replace(Args&&... args) {
method T (line 829) | constexpr const T& value() const& {
method T (line 834) | constexpr T& value() & {
method T (line 839) | constexpr const T&& value() const&& {
method T (line 844) | constexpr T&& value() && {
class Expected<T&, E> (line 855) | class Expected<T&, E> : public detail::ExpectedBase<T*, E, Expected<T&...
type IsExpectedConvertible (line 858) | struct IsExpectedConvertible : FalseType {}
method Expected (line 872) | constexpr Expected(U&& value) : detail::ExpectedBase<T*, E, Expected...
method Expected (line 875) | constexpr Expected(U&& other) {
method T (line 880) | constexpr T& value() const {
class Expected<void, E> (line 890) | class Expected<void, E> : public detail::ExpectedBase<detail::Unit, E,...
method Expected (line 894) | constexpr Expected() : detail::ExpectedBase<detail::Unit, E, Expecte...
method Expected (line 898) | explicit constexpr Expected(const Expected<U, E>& other) {
method Expected (line 904) | explicit constexpr Expected(Expected<U, E>&& other) {
method Expected (line 910) | Expected& operator&=(const Expected<U, E>& other) {
method Expected (line 917) | Expected& operator|=(const Expected<U, E>& other) {
function AllOf (line 928) | Expected<void, E> AllOf(const Expected<T, E>& expected) {
function AllOf (line 934) | Expected<void, E> AllOf(const Expected<T, E>& expected, const Expected...
function Apply (line 942) | auto Apply(F&& func, Args&&... args) -> EnableIf_t<
type ErrorTypeHelper<Expected<Ts, E>...> (line 54) | struct ErrorTypeHelper<Expected<Ts, E>...> : TypeIdentity<E> {}
type IsCallableHelper<F, Pack<Es...>, void_t<ResultType<F, Es...>>> (line 123) | struct IsCallableHelper<F, Pack<Es...>, void_t<ResultType<F, Es...>>> : ...
type IsErrorCallableHelper<F, Pack<Es...>, void_t<ErrorResultType<F, Es...>>> (line 136) | struct IsErrorCallableHelper<F, Pack<Es...>, void_t<ErrorResultType<F, E...
type IsExpectedConvertible<U, void_t<decltype(Declval<U>().value())>> (line 861) | struct IsExpectedConvertible<U, void_t<decltype(Declval<U>().value())>>
FILE: isaac_ros_gxf/gxf/core/include/common/fixed_map.hpp
type nvidia (line 27) | namespace nvidia {
class FixedMap (line 33) | class FixedMap {
class Iterator (line 36) | class Iterator
method Iterator (line 77) | constexpr Iterator() : container_{nullptr}, index_{-1} {}
method Iterator (line 78) | constexpr Iterator(TContainer& container, size_t start) : containe...
method Iterator (line 82) | constexpr Iterator(const Iterator& other) = default;
method Iterator (line 83) | constexpr Iterator(Iterator&& other) = default;
method Iterator (line 84) | constexpr Iterator& operator=(const Iterator& other) = default;
method Iterator (line 85) | constexpr Iterator& operator=(Iterator&& other) = default;
method Iterator (line 99) | constexpr Iterator& operator+=(difference_type offset) {
method Iterator (line 144) | constexpr Iterator& operator++() {
method Iterator (line 148) | constexpr Iterator operator++(int) {
method Iterator (line 153) | constexpr Iterator& operator-=(difference_type offset) {
method Iterator (line 157) | constexpr Iterator& operator--() {
method Iterator (line 161) | constexpr Iterator operator--(int) {
method Iterator (line 167) | constexpr Iterator operator+(Iterator a, difference_type n) {
method Iterator (line 171) | constexpr Iterator operator+(difference_type n, Iterator a) {
method Iterator (line 174) | constexpr Iterator operator-(Iterator a, difference_type n) {
method difference_type (line 178) | constexpr difference_type operator-(const Iterator& a, const Itera...
class ReverseIterator (line 38) | class ReverseIterator
method ReverseIterator (line 208) | constexpr explicit ReverseIterator() : iter_{} {}
method ReverseIterator (line 209) | constexpr explicit ReverseIterator(TIterator iter) : iter_{iter} {}
method ReverseIterator (line 211) | constexpr ReverseIterator(const ReverseIterator& other) = default;
method ReverseIterator (line 212) | constexpr ReverseIterator(ReverseIterator&& other) = default;
method ReverseIterator (line 213) | constexpr ReverseIterator& operator=(const ReverseIterator& other)...
method ReverseIterator (line 214) | constexpr ReverseIterator& operator=(ReverseIterator&& other) = de...
method TIterator (line 216) | constexpr TIterator base() const { return iter_; }
method ReverseIterator (line 220) | constexpr ReverseIterator& operator+=(difference_type offset) {
method ReverseIterator (line 224) | constexpr ReverseIterator& operator++() {
method ReverseIterator (line 228) | constexpr ReverseIterator operator++(int) {
method ReverseIterator (line 233) | constexpr ReverseIterator& operator-=(difference_type offset) {
method ReverseIterator (line 237) | constexpr ReverseIterator& operator--() {
method ReverseIterator (line 241) | constexpr ReverseIterator operator--(int) {
method ReverseIterator (line 247) | constexpr ReverseIterator operator+(ReverseIterator a, difference_...
method ReverseIterator (line 250) | constexpr ReverseIterator operator+(difference_type n, ReverseIter...
method ReverseIterator (line 253) | constexpr ReverseIterator operator-(ReverseIterator a, difference_...
method difference_type (line 256) | constexpr difference_type operator-(const ReverseIterator& a, cons...
type Error (line 53) | enum struct Error {
class Iterator (line 66) | class Iterator {
method Iterator (line 77) | constexpr Iterator() : container_{nullptr}, index_{-1} {}
method Iterator (line 78) | constexpr Iterator(TContainer& container, size_t start) : containe...
method Iterator (line 82) | constexpr Iterator(const Iterator& other) = default;
method Iterator (line 83) | constexpr Iterator(Iterator&& other) = default;
method Iterator (line 84) | constexpr Iterator& operator=(const Iterator& other) = default;
method Iterator (line 85) | constexpr Iterator& operator=(Iterator&& other) = default;
method Iterator (line 99) | constexpr Iterator& operator+=(difference_type offset) {
method Iterator (line 144) | constexpr Iterator& operator++() {
method Iterator (line 148) | constexpr Iterator operator++(int) {
method Iterator (line 153) | constexpr Iterator& operator-=(difference_type offset) {
method Iterator (line 157) | constexpr Iterator& operator--() {
method Iterator (line 161) | constexpr Iterator operator--(int) {
method Iterator (line 167) | constexpr Iterator operator+(Iterator a, difference_type n) {
method Iterator (line 171) | constexpr Iterator operator+(difference_type n, Iterator a) {
method Iterator (line 174) | constexpr Iterator operator-(Iterator a, difference_type n) {
method difference_type (line 178) | constexpr difference_type operator-(const Iterator& a, const Itera...
class ReverseIterator (line 196) | class ReverseIterator {
method ReverseIterator (line 208) | constexpr explicit ReverseIterator() : iter_{} {}
method ReverseIterator (line 209) | constexpr explicit ReverseIterator(TIterator iter) : iter_{iter} {}
method ReverseIterator (line 211) | constexpr ReverseIterator(const ReverseIterator& other) = default;
method ReverseIterator (line 212) | constexpr ReverseIterator(ReverseIterator&& other) = default;
method ReverseIterator (line 213) | constexpr ReverseIterator& operator=(const ReverseIterator& other)...
method ReverseIterator (line 214) | constexpr ReverseIterator& operator=(ReverseIterator&& other) = de...
method TIterator (line 216) | constexpr TIterator base() const { return iter_; }
method ReverseIterator (line 220) | constexpr ReverseIterator& operator+=(difference_type offset) {
method ReverseIterator (line 224) | constexpr ReverseIterator& operator++() {
method ReverseIterator (line 228) | constexpr ReverseIterator operator++(int) {
method ReverseIterator (line 233) | constexpr ReverseIterator& operator-=(difference_type offset) {
method ReverseIterator (line 237) | constexpr ReverseIterator& operator--() {
method ReverseIterator (line 241) | constexpr ReverseIterator operator--(int) {
method ReverseIterator (line 247) | constexpr ReverseIterator operator+(ReverseIterator a, difference_...
method ReverseIterator (line 250) | constexpr ReverseIterator operator+(difference_type n, ReverseIter...
method ReverseIterator (line 253) | constexpr ReverseIterator operator-(ReverseIterator a, difference_...
method difference_type (line 256) | constexpr difference_type operator-(const ReverseIterator& a, cons...
method FixedMap (line 271) | FixedMap() : data_{nullptr}, capacity_{0}, size_{0} {}
method FixedMap (line 272) | FixedMap(const FixedMap& other) = delete;
method FixedMap (line 273) | FixedMap(FixedMap&& other) : data_{nullptr}, capacity_{0}, size_{0} ...
method FixedMap (line 274) | FixedMap& operator=(const FixedMap& other) = delete;
method FixedMap (line 275) | FixedMap& operator=(FixedMap&& other) {
method iterator (line 303) | constexpr iterator begin() { return iterator(*this, 0); }
method iterator (line 304) | constexpr iterator end() { return iterator(*this, size_); }
method reverse_iterator (line 305) | constexpr reverse_iterator rbegin() { return reverse_iterator(end()); }
method reverse_iterator (line 306) | constexpr reverse_iterator rend() { return reverse_iterator(begin(...
method const_iterator (line 308) | constexpr const_iterator begin() const { return cbegin(); }
method const_iterator (line 309) | constexpr const_iterator end() const { return cend(); }
method const_reverse_iterator (line 310) | constexpr const_reverse_iterator rbegin() const { return crbegin(); }
method const_reverse_iterator (line 311) | constexpr const_reverse_iterator rend() const { return crend(); }
method const_iterator (line 313) | constexpr const_iterator cbegin() const { return const_iter...
method const_iterator (line 314) | constexpr const_iterator cend() const { return const_iter...
method const_reverse_iterator (line 315) | constexpr const_reverse_iterator crbegin() const { return const_reve...
method const_reverse_iterator (line 316) | constexpr const_reverse_iterator crend() const { return const_reve...
method size_type (line 334) | size_type capacity() const { return capacity_; }
method size_type (line 336) | size_type size() const { return size_; }
method empty (line 338) | bool empty() const { return size_ == 0; }
method full (line 340) | bool full() const { return size_ == capacity_; }
method load_factor (line 342) | double load_factor() const {
method contains (line 347) | bool contains(const key_type& key) const { return findMatchingBucket...
method at (line 350) | Expected<mapped_type&> at(const key_type& key) {
method at (line 359) | Expected<const mapped_type&> at(const key_type& key) const {
method update (line 368) | Expected<void> update(const key_type& key, const mapped_type& value) {
method insert_or_assign (line 377) | Expected<void> insert_or_assign(Args&&... args) {
method emplace (line 390) | Expected<void> emplace(Args&&... args) {
method insert (line 406) | Expected<void> insert(const value_type& value) { return emplace(valu...
method insert (line 408) | Expected<void> insert(value_type&& value) {
method erase (line 413) | Expected<void> erase(const key_type& key) {
method clear (line 425) | void clear() {
method reserve (line 437) | Expected<void> reserve(size_type capacity) {
method copy_from (line 477) | Expected<void> copy_from(const FixedMap& other) {
type Bucket (line 496) | struct Bucket {
method Bucket (line 502) | Bucket* findMatchingBucket(const key_type& key) const {
method Bucket (line 529) | Bucket* findEmptyBucket(const key_type& key) const {
method size_type (line 552) | size_type hash(const key_type& key) const { return Hash{}(key) % cap...
FILE: isaac_ros_gxf/gxf/core/include/common/fixed_string.hpp
type nvidia (line 27) | namespace nvidia {
class FixedString (line 32) | class FixedString {
type Hash (line 41) | struct Hash {
type Error (line 49) | enum struct Error {
method FixedString (line 59) | constexpr FixedString() { clear(); }
method FixedString (line 61) | constexpr FixedString(const char (&str)[M]) { copy(str); }
method FixedString (line 63) | constexpr FixedString(const FixedString<M>& str) { copy(str); }
method FixedString (line 67) | constexpr FixedString& operator=(const char (&other)[M]) {
method FixedString (line 72) | constexpr FixedString& operator=(const FixedString<M>& other) {
method FixedString (line 77) | constexpr FixedString& operator=(const FixedString& other) {
method const_iterator (line 82) | constexpr const_iterator begin() const { return cbegin(); }
method const_iterator (line 83) | constexpr const_iterator end() const { return cend(); }
method const_reverse_iterator (line 84) | constexpr const_reverse_iterator rbegin() const { return crbegin(); }
method const_reverse_iterator (line 85) | constexpr const_reverse_iterator rend() const { return crend(); }
method const_iterator (line 87) | constexpr const_iterator cbegin() const { return const_iter...
method const_iterator (line 88) | constexpr const_iterator cend() const { return const_iter...
method const_reverse_iterator (line 89) | constexpr const_reverse_iterator crbegin() const { return const_reve...
method const_reverse_iterator (line 90) | constexpr const_reverse_iterator crend() const { return const_reve...
method size (line 119) | constexpr size_t size() const { return size_; }
method length (line 120) | constexpr size_t length() const { return size_; }
method max_size (line 123) | constexpr size_t max_size() const { return kMaxSize; }
method capacity (line 126) | constexpr size_t capacity() const { return kCapacity; }
method empty (line 129) | constexpr bool empty() const { return size_ == 0; }
method full (line 132) | constexpr bool full() const { return size_ == kMaxSize; }
method data (line 135) | constexpr AddLvalueReference_t<const char[N + 1]> data() const { re...
method c_str (line 136) | constexpr AddLvalueReference_t<const char[N + 1]> c_str() const { re...
method clear (line 139) | constexpr void clear() {
method append (line 145) | constexpr Expected<void> append(const char* str, size_t size) {
method append (line 161) | constexpr Expected<void> append(const char (&str)[M]) { return appen...
method append (line 165) | constexpr Expected<void> append(const FixedString<M>& str) {
method append (line 170) | constexpr Expected<void> append(char c) { return append(&c, 1); }
method copy (line 173) | constexpr Expected<void> copy(const char* str, size_t size) {
method copy (line 180) | constexpr void copy(const char (&str)[M]) {
method copy (line 187) | constexpr void copy(const FixedString<M>& str) {
method compare (line 194) | constexpr int compare(const char (&str)[M]) const {
method compare (line 211) | constexpr int compare(const FixedString<M>& str) const { return comp...
FILE: isaac_ros_gxf/gxf/core/include/common/fixed_vector.hpp
type nvidia (line 28) | namespace nvidia {
class FixedVectorBase (line 42) | class FixedVectorBase {
type Error (line 55) | enum struct Error {
method iterator (line 83) | constexpr iterator begin() { return iterator(*this, 0); }
method iterator (line 84) | constexpr iterator end() { return iterator(*this, size_); }
method reverse_iterator (line 85) | constexpr reverse_iterator rbegin() { return reverse_iterator(end()); }
method reverse_iterator (line 86) | constexpr reverse_iterator rend() { return reverse_iterator(begin(...
method const_iterator (line 88) | constexpr const_iterator begin() const { return cbegin(); }
method const_iterator (line 89) | constexpr const_iterator end() const { return cend(); }
method const_reverse_iterator (line 90) | constexpr const_reverse_iterator rbegin() const { return crbegin(); }
method const_reverse_iterator (line 91) | constexpr const_reverse_iterator rend() const { return crend(); }
method const_iterator (line 93) | constexpr const_iterator cbegin() const { return const_iter...
method const_iterator (line 94) | constexpr const_iterator cend() const { return const_iter...
method const_reverse_iterator (line 95) | constexpr const_reverse_iterator crbegin() const { return const_reve...
method const_reverse_iterator (line 96) | constexpr const_reverse_iterator crend() const { return const_reve...
method T (line 102) | constexpr T* data() { return data_; }
method T (line 104) | constexpr const T* data() const { return data_; }
method capacity (line 106) | constexpr size_t capacity() const { return capacity_; }
method size (line 108) | constexpr size_t size() const { return size_; }
method empty (line 110) | constexpr bool empty() const { return size_ == 0; }
method full (line 112) | constexpr bool full() const { return size_ == capacity_; }
method at (line 115) | constexpr Expected<T&> at(size_t index) {
method at (line 123) | constexpr Expected<const T&> at(size_t index) const {
method front (line 131) | constexpr Expected<T&> front() {
method front (line 139) | constexpr Expected<const T&> front() const {
method back (line 147) | constexpr Expected<T&> back() {
method back (line 155) | constexpr Expected<const T&> back() const {
method emplace (line 164) | constexpr Expected<void> emplace(size_t index, Args&&... args) {
method emplace_back (line 181) | constexpr Expected<void> emplace_back(Args&&... args) {
method insert (line 186) | constexpr Expected<void> insert(size_t index, const T& obj) { return...
method insert (line 188) | constexpr Expected<void> insert(size_t index, T&& obj) {
method insert (line 193) | constexpr Expected<void> insert(iterator index, const_iterator start...
method push_back (line 216) | constexpr Expected<void> push_back(const T& obj) { return emplace_ba...
method push_back (line 218) | constexpr Expected<void> push_back(T&& obj) { return emplace_back(st...
method erase (line 221) | constexpr Expected<void> erase(size_t index) {
method pop_back (line 237) | constexpr Expected<void> pop_back() { return erase(size_ - 1); }
method clear (line 240) | constexpr void clear() {
method resize (line 248) | constexpr Expected<void> resize(size_t count) {
method resize (line 263) | constexpr Expected<void> resize(size_t count, const T& obj) {
method FixedVectorBase (line 280) | FixedVectorBase() : data_{nullptr}, capacity_{0}, size_{0} {}
class FixedVector (line 295) | class FixedVector : public FixedVectorBase<T> {
method FixedVector (line 299) | constexpr FixedVector() {
method FixedVector (line 303) | constexpr FixedVector(const FixedVector& other) { *this = other; }
method FixedVector (line 304) | constexpr FixedVector(FixedVector&& other) { *this = std::move(other...
method FixedVector (line 305) | constexpr FixedVector& operator=(const FixedVector& other) {
method FixedVector (line 314) | constexpr FixedVector& operator=(FixedVector&& other) {
class FixedVector<T, kFixedVectorHeap> (line 338) | class FixedVector<T, kFixedVectorHeap> : public FixedVectorBase<T> {
method FixedVector (line 343) | constexpr FixedVector() = default;
method FixedVector (line 344) | constexpr FixedVector(const FixedVector& other) = delete;
method FixedVector (line 345) | constexpr FixedVector(FixedVector&& other) { *this = std::move(other...
method FixedVector (line 346) | constexpr FixedVector& operator=(const FixedVector& other) = delete;
method FixedVector (line 347) | constexpr FixedVector& operator=(FixedVector&& other) {
method copy_from (line 363) | constexpr Expected<void> copy_from(const FixedVector& other) {
method reserve (line 374) | constexpr Expected<void> reserve(size_t capacity) {
method shrink_to_fit (line 389) | constexpr Expected<void> shrink_to_fit() {
FILE: isaac_ros_gxf/gxf/core/include/common/iterator.hpp
type nvidia (line 25) | namespace nvidia {
type detail (line 27) | namespace detail {
type HasData (line 30) | struct HasData : FalseType {}
type HasSize (line 35) | struct HasSize : FalseType {}
class RandomAccessIterator (line 47) | class RandomAccessIterator {
type Error (line 54) | enum struct Error {
method RandomAccessIterator (line 68) | constexpr RandomAccessIterator() : container_{nullptr}, index_{-1} {}
method RandomAccessIterator (line 69) | constexpr RandomAccessIterator(TContainer& container, size_t start)
method RandomAccessIterator (line 78) | constexpr RandomAccessIterator(const RandomAccessIterator<OContainer...
method RandomAccessIterator (line 83) | constexpr RandomAccessIterator(const RandomAccessIterator& other) = ...
method RandomAccessIterator (line 84) | constexpr RandomAccessIterator(RandomAccessIterator&& other) = default;
method RandomAccessIterator (line 85) | constexpr RandomAccessIterator& operator=(const RandomAccessIterator...
method RandomAccessIterator (line 86) | constexpr RandomAccessIterator& operator=(RandomAccessIterator&& oth...
method RandomAccessIterator (line 103) | constexpr RandomAccessIterator& operator+=(difference_type offset) {
method RandomAccessIterator (line 116) | constexpr RandomAccessIterator& operator++() {
method RandomAccessIterator (line 120) | constexpr RandomAccessIterator operator++(int) {
method RandomAccessIterator (line 125) | constexpr RandomAccessIterator& operator-=(difference_type offset) {
method RandomAccessIterator (line 129) | constexpr RandomAccessIterator& operator--() {
method RandomAccessIterator (line 133) | constexpr RandomAccessIterator operator--(int) {
method RandomAccessIterator (line 139) | constexpr RandomAccessIterator operator+(RandomAccessIterator a, dif...
method RandomAccessIterator (line 143) | constexpr RandomAccessIterator operator+(difference_type n, RandomAc...
method RandomAccessIterator (line 146) | constexpr RandomAccessIterator operator-(RandomAccessIterator a, dif...
method difference_type (line 150) | constexpr difference_type operator-(const RandomAccessIterator& a,
class ReverseIterator (line 176) | class ReverseIterator {
method ReverseIterator (line 191) | constexpr explicit ReverseIterator() : iter_{} {}
method ReverseIterator (line 192) | constexpr explicit ReverseIterator(TIterator iter) : iter_{iter} {}
method ReverseIterator (line 194) | constexpr ReverseIterator(const ReverseIterator& other) = default;
method ReverseIterator (line 195) | constexpr ReverseIterator(ReverseIterator&& other) = default;
method ReverseIterator (line 196) | constexpr ReverseIterator& operator=(const ReverseIterator& other) =...
method ReverseIterator (line 197) | constexpr ReverseIterator& operator=(ReverseIterator&& other) = defa...
method TIterator (line 199) | constexpr TIterator base() const { return iter_; }
method ReverseIterator (line 206) | constexpr ReverseIterator& operator+=(difference_type offset) {
method ReverseIterator (line 210) | constexpr ReverseIterator& operator++() {
method ReverseIterator (line 214) | constexpr ReverseIterator operator++(int) {
method ReverseIterator (line 219) | constexpr ReverseIterator& operator-=(difference_type offset) {
method ReverseIterator (line 223) | constexpr ReverseIterator& operator--() {
method ReverseIterator (line 227) | constexpr ReverseIterator operator--(int) {
method ReverseIterator (line 233) | constexpr ReverseIterator operator+(ReverseIterator a, difference_ty...
method ReverseIterator (line 236) | constexpr ReverseIterator operator+(difference_type n, ReverseIterat...
method ReverseIterator (line 239) | constexpr ReverseIterator operator-(ReverseIterator a, difference_ty...
method difference_type (line 242) | constexpr difference_type operator-(const ReverseIterator& a, const ...
type HasData<T, void_t<decltype(Declval<T>().data())>> (line 31) | struct HasData<T, void_t<decltype(Declval<T>().data())>> : TrueType {}
type HasSize<T, void_t<decltype(Declval<T>().size())>> (line 36) | struct HasSize<T, void_t<decltype(Declval<T>().size())>> : TrueType {}
FILE: isaac_ros_gxf/gxf/core/include/common/logger.hpp
type nvidia (line 124) | namespace nvidia {
function Log (line 161) | void Log(const char* file, int line, Severity severity, const char* tx...
FILE: isaac_ros_gxf/gxf/core/include/common/memory_utils.hpp
type nvidia (line 28) | namespace nvidia {
function T (line 32) | T* ValuePointer(byte* src) {
function T (line 38) | const T* ValuePointer(const byte* src) {
function byte (line 44) | byte* BytePointer(T* src) {
function byte (line 50) | const byte* BytePointer(const T* src) {
function Destruct (line 56) | void Destruct(byte* src) {
function T (line 63) | T* InplaceConstruct(byte* dst, Args&&... args) {
function T (line 69) | T* InplaceMoveConstruct(byte* dst, T&& other) {
function T (line 75) | T* InplaceCopyConstruct(byte* dst, const T& other) {
function ArrayMoveConstruct (line 82) | void ArrayMoveConstruct(byte* dst, T* src, size_t count) {
function ArrayMoveConstruct (line 95) | void ArrayMoveConstruct(byte* dst, T* src, size_t count) {
function ArrayMoveConstruct (line 103) | void ArrayMoveConstruct(byte* dst, T* src, size_t count) {
function ArrayCopyConstruct (line 115) | void ArrayCopyConstruct(byte* dst, T* src, size_t count) {
function ArrayCopyConstruct (line 122) | void ArrayCopyConstruct(byte* dst, T* src, size_t count) {
function T (line 134) | T* AllocateArray(size_t size) {
function DeallocateArray (line 141) | void DeallocateArray(T* data) {
function MakeUniqueNoThrow (line 148) | std::unique_ptr<T> MakeUniqueNoThrow(Args&&... args) {
function MakeSharedNoThrow (line 155) | std::shared_ptr<T> MakeSharedNoThrow(Args&&... args) {
FILE: isaac_ros_gxf/gxf/core/include/common/nvtx_helper.hpp
function nvtxEventAttributes_t (line 26) | inline nvtxEventAttributes_t CreateGreenEvent(const std::string& message...
function nvtxEventAttributes_t (line 39) | inline nvtxEventAttributes_t CreateRedEvent(const std::string& message, ...
function nvtxEventAttributes_t (line 53) | inline nvtxEventAttributes_t CreateBlackEvent(const std::string& message...
function nvtxEventAttributes_t (line 66) | inline nvtxEventAttributes_t CreateBlueEvent(const std::string& message,...
FILE: isaac_ros_gxf/gxf/core/include/common/singleton.hpp
type gxf (line 20) | namespace gxf {
type Singleton (line 30) | struct Singleton {
method Singleton (line 32) | Singleton& operator=(Singleton&) = delete;
method T (line 35) | static T& Get() {
method Use (line 43) | static void Use(const T&) {}
FILE: isaac_ros_gxf/gxf/core/include/common/span.hpp
type nvidia (line 25) | namespace nvidia {
type detail (line 27) | namespace detail {
class Span (line 43) | class Span {
type Error (line 52) | enum struct Error {
method Span (line 61) | constexpr Span(T* data, size_t size) : data_{data}, size_{data != nu...
method Span (line 62) | constexpr Span() : Span(nullptr, 0) {}
method Span (line 64) | constexpr Span(T (&array)[N]) : Span(array, N) {}
method Span (line 67) | constexpr Span(U& other) : Span(other.data(), other.size()) {}
method Span (line 74) | constexpr Span(const Span& other) = default;
method Span (line 75) | constexpr Span(Span&& other) = default;
method Span (line 76) | constexpr Span& operator=(const Span&) = default;
method Span (line 77) | constexpr Span& operator=(Span&&) = default;
method iterator (line 79) | constexpr iterator begin() const { return iterator(*this, 0...
method iterator (line 80) | constexpr iterator end() const { return iterator(*this, s...
method reverse_iterator (line 81) | constexpr reverse_iterator rbegin() const { return reverse_iterator(...
method reverse_iterator (line 82) | constexpr reverse_iterator rend() const { return reverse_iterator(...
method T (line 87) | constexpr T* data() const { return data_; }
method size (line 89) | constexpr size_t size() const { return size_; }
method size_bytes (line 91) | constexpr size_t size_bytes() const { return size_ * sizeof(T); }
method empty (line 93) | constexpr bool empty() const { return size_ == 0; }
method at (line 96) | constexpr Expected<T&> at(size_t index) const {
method front (line 102) | constexpr Expected<T&> front() const {
method back (line 108) | constexpr Expected<T&> back() const {
method subspan (line 114) | constexpr Expected<Span> subspan(size_t offset, size_t count) const {
method subspan (line 121) | constexpr Expected<Span> subspan(size_t offset) const { return subsp...
method first (line 123) | constexpr Expected<Span> first(size_t count) const { return subspan(...
method last (line 125) | constexpr Expected<Span> last(size_t count) const { return subspan(s...
FILE: isaac_ros_gxf/gxf/core/include/common/strong_type.hpp
type nvidia (line 25) | namespace nvidia {
class StrongType (line 60) | class StrongType {
method StrongType (line 67) | constexpr StrongType() = default;
method StrongType (line 73) | constexpr explicit
method value_type (line 81) | constexpr value_type const& value() const & noexcept { return val...
method value_type (line 82) | constexpr value_type& value() & noexcept { return val...
method value_type (line 83) | constexpr value_type&& value() && noexcept { return std...
method value_type (line 84) | constexpr value_type const* operator->() const noexcept { return &va...
method value_type (line 85) | constexpr value_type* operator->() noexcept { return &va...
FILE: isaac_ros_gxf/gxf/core/include/common/type_name.hpp
type nvidia (line 33) | namespace nvidia {
type helper (line 34) | namespace helper {
function PrettyFunctionSize (line 54) | constexpr int32_t PrettyFunctionSize() {
type nvidia (line 60) | namespace nvidia {
type helper (line 34) | namespace helper {
function PrettyFunctionSize (line 54) | constexpr int32_t PrettyFunctionSize() {
FILE: isaac_ros_gxf/gxf/core/include/common/type_name_gnuc.hpp
type nvidia (line 22) | namespace nvidia {
FILE: isaac_ros_gxf/gxf/core/include/common/type_utils.hpp
type nvidia (line 25) | namespace nvidia {
type TypeIdentity (line 31) | struct TypeIdentity { using type = T; }
type IntegralConstant (line 36) | struct IntegralConstant { static constexpr T value = v; }
type BoolConstant (line 37) | struct BoolConstant : IntegralConstant<bool, B> {}
type TrueType (line 39) | struct TrueType : BoolConstant<true> {}
type FalseType (line 40) | struct FalseType : BoolConstant<false> {}
type Conditional (line 43) | struct Conditional : TypeIdentity<T> {}
type Conditional<false, T, F> (line 44) | struct Conditional<false, T, F> : TypeIdentity<F> {}
type Conjunction (line 50) | struct Conjunction : TrueType {}
type Disjunction (line 59) | struct Disjunction : FalseType {}
type Negation (line 67) | struct Negation : BoolConstant<!static_cast<bool>(B::value)> {}
type RemoveReference (line 72) | struct RemoveReference : TypeIdentity<T> {}
type RemoveReference<T&> (line 73) | struct RemoveReference<T&> : TypeIdentity<T> {}
type RemoveReference<T&&> (line 74) | struct RemoveReference<T&&> : TypeIdentity<T> {}
type RemoveCV (line 79) | struct RemoveCV : TypeIdentity<T> {}
type RemoveCV<const T> (line 80) | struct RemoveCV<const T> : TypeIdentity<T> {}
type RemoveCV<volatile T> (line 81) | struct RemoveCV<volatile T> : TypeIdentity<T> {}
type RemoveCV<const volatile T> (line 82) | struct RemoveCV<const volatile T> : TypeIdentity<T> {}
type RemoveConst (line 86) | struct RemoveConst : TypeIdentity<T> {}
type RemoveConst<const T> (line 87) | struct RemoveConst<const T> : TypeIdentity<T> {}
type RemoveVolatile (line 91) | struct RemoveVolatile : TypeIdentity<T> {}
type RemoveVolatile<volatile T> (line 92) | struct RemoveVolatile<volatile T> : TypeIdentity<T> {}
type RemoveCVRef (line 97) | struct RemoveCVRef : RemoveCV<typename RemoveReference<T>::type>{}
type AddLvalueReference (line 103) | struct AddLvalueReference {
type AddRvalueReference (line 112) | struct AddRvalueReference {
function Declval (line 125) | AddRvalueReference_t<T> Declval() noexcept {
type Decay (line 132) | struct Decay {
method Id (line 134) | static constexpr auto Id(U u) noexcept { return u; }
method Test (line 136) | static constexpr void Test(...) {}
type EnableIf (line 144) | struct EnableIf {}
type EnableIf<true, T> (line 145) | struct EnableIf<true, T> : TypeIdentity<T> {}
type IsSame (line 150) | struct IsSame : FalseType {}
type IsSame<T, T> (line 151) | struct IsSame<T, T> : TrueType {}
type IsVoid (line 156) | struct IsVoid : IsSame<void, typename RemoveCV<T>::type> {}
type IsConst (line 161) | struct IsConst : FalseType {}
type IsConst<const T> (line 162) | struct IsConst<const T> : TrueType {}
type IsReference (line 167) | struct IsReference : FalseType {}
type IsReference<T&> (line 168) | struct IsReference<T&> : TrueType {}
type IsReference<T&&> (line 169) | struct IsReference<T&&> : TrueType {}
type IsConstructible (line 175) | struct IsConstructible {
method TestCast (line 178) | static constexpr bool TestCast(void*) { return true; }
method TestCast (line 181) | static constexpr bool TestCast(...) { return false; }
type Test (line 184) | struct Test : FalseType {}
type Test<1, U, void> (line 187) | struct Test<1, U, void> : BoolConstant<TestCast<Args...>(nullptr)> {}
type IsNothrowConstructible (line 208) | struct IsNothrowConstructible {
method TestCast (line 211) | static constexpr bool TestCast(void*) { return Result; }
method TestCast (line 214) | static constexpr bool TestCast(...) { return false; }
type Test (line 217) | struct Test : FalseType {}
type Test<0, U, void_t<decltype(U())>> (line 220) | struct Test<0, U, void_t<decltype(U())>> : BoolConstant<noexcept(U()...
type Test<1, U, void> (line 223) | struct Test<1, U, void> : BoolConstant<TestCast<Args...>(nullptr)> {}
type IsConvertible (line 245) | struct IsConvertible {
method Test (line 248) | static constexpr bool Test(void*) { return true; }
method Test (line 250) | static constexpr bool Test(...) { return false; }
type IsNothrowConvertible (line 260) | struct IsNothrowConvertible {
method Test (line 265) | static constexpr bool Test(void*) { return Result; }
method Test (line 267) | static constexpr bool Test(...) { return false; }
type IsAssignable (line 277) | struct IsAssignable : FalseType {}
type IsAssignable<T, U, void_t<decltype(Declval<T>() = Declval<U>())>> (line 280) | struct IsAssignable<T, U, void_t<decltype(Declval<T>() = Declval<U>())...
type IsIntegral (line 286) | struct IsIntegral : BoolConstant<
type IsFloatingPoint (line 301) | struct IsFloatingPoint : BoolConstant<
type IsArithmetic (line 310) | struct IsArithmetic : BoolConstant<IsIntegral_v<T> || IsFloatingPoint_...
type IsSigned (line 315) | struct IsSigned : BoolConstant<(T(-1) < T(0))> {}
type IsSigned<T, false> (line 316) | struct IsSigned<T, false> : FalseType {}
type IsUnsigned (line 320) | struct IsUnsigned : BoolConstant<(T(0) < T(-1))> {}
type IsUnsigned<T, false> (line 321) | struct IsUnsigned<T, false> : FalseType {}
type MakeSigned (line 325) | struct MakeSigned : TypeIdentity<T> {}
type MakeSigned<uint8_t> (line 326) | struct MakeSigned<uint8_t> : TypeIdentity<int8_t> {}
type MakeSigned<uint16_t> (line 327) | struct MakeSigned<uint16_t> : TypeIdentity<int16_t> {}
type MakeSigned<uint32_t> (line 328) | struct MakeSigned<uint32_t> : TypeIdentity<int32_t> {}
type MakeSigned<uint64_t> (line 329) | struct MakeSigned<uint64_t> : TypeIdentity<int64_t> {}
type MakeUnsigned (line 333) | struct MakeUnsigned : TypeIdentity<T> {}
type MakeUnsigned<int8_t> (line 334) | struct MakeUnsigned<int8_t> : TypeIdentity<uint8_t> {}
type MakeUnsigned<int16_t> (line 335) | struct MakeUnsigned<int16_t> : TypeIdentity<uint16_t> {}
type MakeUnsigned<int32_t> (line 336) | struct MakeUnsigned<int32_t> : TypeIdentity<uint32_t> {}
type MakeUnsigned<int64_t> (line 337) | struct MakeUnsigned<int64_t> : TypeIdentity<uint64_t> {}
type Conjunction<B, Bs...> (line 53) | struct Conjunction<B, Bs...> : Conditional<B::value, Conjunction<Bs...>,...
type Disjunction<B, Bs...> (line 62) | struct Disjunction<B, Bs...> : Conditional<B::value, B, Disjunction<Bs.....
type Test<I, U, void_t<decltype(new U(Declval<Args>()...))>> (line 190) | struct Test<I, U, void_t<decltype(new U(Declval<Args>()...))>> : TrueTyp...
type Test<I, U, void_t<decltype(new U(Declval<Args>()...))>> (line 226) | struct Test<I, U, void_t<decltype(new U(Declval<Args>()...))>>
FILE: isaac_ros_gxf/gxf/core/include/common/unique_index_map.hpp
type nvidia (line 23) | namespace nvidia {
class UniqueIndexMap (line 30) | class UniqueIndexMap {
type Error (line 47) | enum struct Error {
method UniqueIndexMap (line 58) | UniqueIndexMap() : uids_{nullptr}, data_{nullptr}, capacity_{0}, siz...
method UniqueIndexMap (line 59) | UniqueIndexMap(const UniqueIndexMap<T>&) = delete;
method UniqueIndexMap (line 60) | UniqueIndexMap(UniqueIndexMap<T>&& other)
method deinitialize (line 87) | void deinitialize() {
method initialize (line 101) | Expected<void> initialize(uint64_t max_capacity) {
method valid (line 123) | bool valid(uint64_t uid) const {
method insert (line 130) | Expected<uint64_t> insert(T&& object) { return emplace(static_cast<T...
method insert (line 134) | Expected<uint64_t> insert(const T& object) { return emplace(object); }
method emplace (line 139) | Expected<uint64_t> emplace(Args&&... args) {
method erase (line 158) | Expected<void> erase(uint64_t uid) {
method try_get (line 173) | Expected<T*> try_get(uint64_t uid) {
method try_get (line 181) | Expected<const T*> try_get(uint64_t uid) const {
method find (line 190) | Expected<uint64_t> find(const T& object) const {
method capacity (line 200) | inline uint64_t capacity() const { return capacity_; }
method size (line 203) | inline uint64_t size() const { return size_; }
method GetVersion (line 206) | static uint64_t GetVersion(uint64_t uid) { return uid >> kIndexSize; }
method GetIndex (line 207) | static uint64_t GetIndex(uint64_t uid) { return uid & kIndexMask; }
method reset_values (line 211) | void reset_values() {
FILE: isaac_ros_gxf/gxf/core/include/common/yaml_parser.hpp
function is_space (line 30) | inline static bool is_space(unsigned char c) {
type YAML::convert<std::complex<T>> (line 48) | struct YAML::convert<std::complex<T>> {
method Node (line 49) | static Node encode(const std::complex<T>& data) {
method decode (line 60) | static bool decode(const Node& node, std::complex<T>& data) {
FILE: isaac_ros_gxf/gxf/core/include/dlpack/dlpack.h
type DLDeviceType (line 58) | typedef enum {
type DLDevice (line 108) | typedef struct {
type DLDataTypeCode (line 121) | typedef enum {
type DLDataType (line 156) | typedef struct {
type DLTensor (line 174) | typedef struct {
type DLManagedTensor (line 226) | typedef struct DLManagedTensor {
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/application.hpp
type nvidia (line 39) | namespace nvidia {
type gxf (line 41) | namespace gxf {
function create_app (line 44) | std::shared_ptr<T> create_app(Args&&... args) {
type ExecutionMode (line 54) | enum class ExecutionMode : int8_t {
class Application (line 67) | class Application : public Segment {
method Application (line 76) | Application(const Application&) = delete;
method Application (line 78) | Application& operator=(const Application&) = delete;
method Application (line 80) | Application(Application&&) = delete;
method Application (line 82) | Application& operator=(Application&&) = delete;
method compose (line 84) | virtual void compose() {}
method createSegment (line 115) | std::shared_ptr<SegmentT> createSegment(const char* name) {
method setWorker (line 195) | Expected<void> setWorker(const std::string& name, Args... args) {
method setDriver (line 254) | Expected<void> setDriver(const std::string& name, Args... args) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/arg.hpp
type nvidia (line 37) | namespace nvidia {
type gxf (line 39) | namespace gxf {
class ProxyComponent (line 41) | class ProxyComponent
type ArgInfo (line 47) | struct ArgInfo {
type ArgOverride (line 60) | struct ArgOverride {
method apply (line 61) | static Expected<void> apply(ArgInfo& info) {
method wrap (line 69) | static Expected<YAML::Node> wrap(const T& value) { return YAML::No...
type ArgOverride<Handle<T>> (line 78) | struct ArgOverride<Handle<T>> {
method apply (line 79) | static Expected<void> apply(ArgInfo& info) {
method wrap (line 86) | static Expected<YAML::Node> wrap(const Handle<T>& value) {
type ArgOverride<std::vector<T>> (line 112) | struct ArgOverride<std::vector<T>> {
method apply (line 113) | static Expected<void> apply(ArgInfo& info) {
method wrap (line 132) | static Expected<YAML::Node> wrap(const std::vector<T>& value) {
type ArgOverride<std::array<T, N>> (line 150) | struct ArgOverride<std::array<T, N>> {
method apply (line 151) | static Expected<void> apply(ArgInfo& info) {
method wrap (line 170) | static Expected<YAML::Node> wrap(const std::array<T, N>& value) {
type ArgOverride<ProxyComponent> (line 186) | struct ArgOverride<ProxyComponent> {
method apply (line 187) | static Expected<void> apply(ArgInfo& info) {
method wrap (line 193) | static Expected<YAML::Node> wrap(const ProxyComponent& value) { re...
function Arg (line 206) | explicit Arg(const std::string& key) : key_(key) {}
function Arg (line 209) | Arg(const std::string& key, const T& value) {
function Arg (line 222) | Arg(const std::string& key, const Handle<T>& value) {
function Arg (line 239) | Arg(const std::string& key, const char* value) {
function Arg (line 251) | Arg(const std::string& key, const ProxyComponent& value) {
function Arg (line 262) | Arg(const std::string& key, T&& value) {
function Arg (line 275) | Arg(const std::string& key, Handle<T>&& value) {
function Arg (line 292) | Arg(const std::string& key, ProxyComponent&& value) {
function Arg (line 303) | Arg& operator=(const T& value) {
function Arg (line 315) | Arg& operator=(const Handle<T>& value) {
function Arg (line 331) | Arg& operator=(ProxyComponent& value) {
function Arg (line 343) | Arg&& operator=(T&& value) {
function if (line 360) | if (!result) {
function if (line 364) | if (!value.is_null()) {
function Arg (line 374) | Arg&& operator=(ProxyComponent&& value) {
function T (line 385) | T as() const {
function gxf_uid_t (line 394) | const gxf_uid_t handle_uid() const { return handle_cid_; }
function gxf_tid_t (line 396) | const gxf_tid_t handle_tid() const { return handle_tid_; }
function arg_type_name (line 400) | const std::string arg_type_name() const { return info_.type_name; }
function ArgInfo (line 402) | const ArgInfo arg_info() const { return info_; }
function yaml_node (line 404) | const YAML::Node yaml_node() const { return yaml_node_; }
function rank (line 406) | const int32_t rank() const { return info_.rank; }
function shape (line 408) | const std::array<int32_t, ParameterInfo<int32_t>::kMaxRank> shape() co...
function gxf_parameter_type_t (line 410) | const gxf_parameter_type_t parameter_type() const { return info_.type; }
function has_value (line 412) | bool has_value() const { return value_.has_value(); }
function value (line 414) | std::any value() const { return value_; }
function set_value (line 425) | void set_value(const T& value) {
function set_value (line 437) | void set_value(T&& value) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/arg_parse.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
function parseArgsOfType (line 39) | std::vector<T> parseArgsOfType(const First& first, const Rest&... re...
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/config_parser.hpp
type YAML (line 27) | namespace YAML { class Node; }
class Node (line 27) | class Node
type nvidia (line 29) | namespace nvidia {
type gxf (line 30) | namespace gxf {
class ConfigParser (line 52) | class ConfigParser {
type SegmentConfig (line 54) | struct SegmentConfig {
type EnabledSegments (line 55) | struct EnabledSegments {
type Worker (line 58) | struct Worker {
type Driver (line 65) | struct Driver {
method ConfigParser (line 75) | ConfigParser() {
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/driver.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class Application (line 30) | class Application
class Driver (line 37) | class Driver {
method name (line 41) | std::string name() { return name_; }
method setPort (line 42) | Expected<void> setPort(uint32_t port) { port_ = port; return Succe...
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/entity_group.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class EntityGroup (line 36) | class EntityGroup {
method EntityGroup (line 38) | EntityGroup() = default;
method EntityGroup (line 42) | EntityGroup(const EntityGroup&) = delete;
method EntityGroup (line 44) | EntityGroup& operator=(const EntityGroup&) = delete;
method gxf_uid_t (line 75) | gxf_uid_t gid() const { return gid_; }
method name (line 80) | std::string name() const { return name_; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/extension_manager.hpp
type nvidia (line 30) | namespace nvidia {
type gxf (line 31) | namespace gxf {
class ExtensionManager (line 37) | class ExtensionManager {
method ExtensionManager (line 39) | ExtensionManager() = default;
method ExtensionManager (line 42) | ExtensionManager(const ExtensionManager&) = delete;
method ExtensionManager (line 43) | ExtensionManager(ExtensionManager&&) = delete;
method ExtensionManager (line 44) | ExtensionManager& operator=(const ExtensionManager&) = delete;
method ExtensionManager (line 45) | ExtensionManager& operator=(ExtensionManager&&) = delete;
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/graph_entity.hpp
type nvidia (line 39) | namespace nvidia {
type gxf (line 40) | namespace gxf {
class GraphEntity (line 47) | class GraphEntity {
method GraphEntity (line 49) | GraphEntity() = default;
method GraphEntity (line 53) | GraphEntity(const GraphEntity&) = delete;
method GraphEntity (line 55) | GraphEntity& operator=(const GraphEntity&) = delete;
method setup (line 63) | Expected<void> setup(gxf_context_t context, const char* name) {
method add (line 87) | Handle<T> add(const char* name = nullptr, Args && ... args) {
method add (line 106) | Handle<T> add(const char* name, std::vector<Arg> arg_list) {
method findAll (line 119) | FixedVector<Handle<T>, N> findAll() const {
method get (line 133) | Handle<T> get(const char* name = nullptr) const {
method try_get (line 154) | Expected<Handle<T>> try_get(const char* name = nullptr) const {
method addCodelet (line 190) | Handle<T> addCodelet(const char* name = nullptr, Args... args) {
method addClock (line 235) | Handle<T> addClock(const char* name = nullptr, Args... args) {
method addSchedulingTerm (line 271) | Handle<T> addSchedulingTerm(const char* name = nullptr, Args... ar...
method addTransmitter (line 311) | Handle<T> addTransmitter(const char* name, bool omit_term = false,...
method getTransmitter (line 365) | Handle<Transmitter> getTransmitter(const char* name) {
method addReceiver (line 394) | Handle<T> addReceiver(const char* name, bool omit_term = false, Ar...
method getReceiver (line 448) | Handle<Receiver> getReceiver(const char* name) {
method configTransmitter (line 465) | Expected<void> configTransmitter(const char* name, uint64_t capaci...
method configReceiver (line 497) | Expected<void> configReceiver(const char* name, uint64_t capacity,...
method activate (line 519) | Expected<void> activate() { return entity_.activate(); }
method deactivate (line 521) | Expected<void> deactivate() { return entity_.deactivate(); }
method gxf_context_t (line 523) | gxf_context_t context() const { return entity_.context(); }
method gxf_uid_t (line 525) | gxf_uid_t eid() const { return entity_.eid(); }
method is_null (line 527) | bool is_null() const { return entity_.is_null(); }
method get_codelet (line 529) | Handle<Codelet> get_codelet() { return codelet_; }
method addComponent (line 569) | Expected<Handle<T>> addComponent(const char* name = nullptr,
method createHandle (line 642) | Expected<Handle<T>> createHandle(const char* type_name, const char...
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/graph_utils.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
function gxf_tid_t (line 27) | static gxf_tid_t generate_tid() {
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/proxy_component.hpp
type nvidia (line 30) | namespace nvidia {
type gxf (line 31) | namespace gxf {
class ProxyComponent (line 38) | class ProxyComponent {
method ProxyComponent (line 40) | ProxyComponent() {}
method ProxyComponent (line 41) | ProxyComponent(const std::string& type_name, const std::string& co...
method type_name (line 45) | std::string type_name() const { return typename_; }
method name (line 47) | std::string name() const { return component_name_; }
method args (line 49) | std::vector<Arg> args() const { return args_; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/segment.hpp
type nvidia (line 44) | namespace nvidia {
type gxf (line 45) | namespace gxf {
type PortPair (line 54) | struct PortPair {
method PortPair (line 55) | PortPair(std::string tx, std::string rx) : tx(tx), rx(rx) {}
type SegmentPort (line 68) | struct SegmentPort {
method split_string (line 69) | auto split_string(std::string port_name) {
method split_string2 (line 86) | auto split_string2(std::string port_name) {
method to_string (line 104) | std::string to_string() {
method SegmentPort (line 112) | SegmentPort(std::string name) {
type SegmentPortPair (line 140) | struct SegmentPortPair {
method SegmentPortPair (line 141) | SegmentPortPair(std::string tx, std::string rx) : tx(tx), rx(rx) {}
type SchedulerType (line 155) | enum class SchedulerType: int8_t {
class Segment (line 173) | class Segment {
method Segment (line 175) | Segment() = default;
method Segment (line 179) | Segment(Segment&&) = delete;
method Segment (line 181) | Segment& operator=(Segment&&) = delete;
method Segment (line 183) | Segment(const Segment&) = delete;
method Segment (line 185) | Segment& operator=(const Segment&) = delete;
method compose (line 187) | virtual void compose() {}
method GraphEntityPtr (line 203) | GraphEntityPtr makeEntity(const char* name, Args... args) {
method GraphEntityPtr (line 250) | GraphEntityPtr makeEntity(const char* name, Args... args) {
method EntityGroupPtr (line 262) | EntityGroupPtr makeEntityGroup(const char* name,
method ProxyComponent (line 282) | ProxyComponent makeTerm(const char* name, Args... args) {
method ProxyComponent (line 303) | ProxyComponent makeResource(const char* name, Args... args) {
method setClock (line 325) | Handle<Clock> setClock(const char* name, Args... args) {
method setScheduler (line 346) | Handle<Scheduler> setScheduler(Args... args) {
method getEntity (line 406) | std::shared_ptr<GraphEntity> getEntity(const char* name) {
method gxf_context_t (line 426) | gxf_context_t context() { return context_; }
method activate (line 433) | Expected<void> activate() {
method deactivate (line 444) | Expected<void> deactivate() {
method run (line 456) | Expected<void> run() {
method runAsync (line 468) | Expected<void> runAsync() {
method interrupt (line 481) | Expected<void> interrupt() {
method wait (line 492) | Expected<void> wait() {
method gxf_result_t (line 506) | gxf_result_t setSeverity(gxf_severity_t severity) { return GxfSetS...
method saveToFile (line 515) | Expected<void> saveToFile(const char* filepath) {
method loadParameterFile (line 527) | Expected<void> loadParameterFile(const char* filepath) {
method setup (line 560) | Expected<void> setup(gxf_context_t segment_context, const char* name,
method setName (line 569) | Expected<void> setName(const char* name) {
method checkConfiguration (line 574) | Expected<void> checkConfiguration() { return Success; }
method GraphEntityPtr (line 583) | GraphEntityPtr createGraphEntity(std::string name) {
method EntityGroupPtr (line 599) | EntityGroupPtr createEntityGroup(std::string name) {
method gxf_result_t (line 611) | gxf_result_t registerCodelet() {
type SegmentConnection (line 635) | struct SegmentConnection {
method SegmentConnection (line 636) | SegmentConnection(SegmentPtr source, SegmentPtr target, std::vecto...
type Hash (line 657) | struct Hash {
FILE: isaac_ros_gxf/gxf/core/include/gxf/app/worker.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class Application (line 31) | class Application
class Worker (line 38) | class Worker {
method name (line 42) | std::string name() { return name_; }
method setPort (line 43) | Expected<void> setPort(uint32_t port) { port_ = port; return Succe...
method setDriverIp (line 44) | Expected<void> setDriverIp(const std::string& ip) { driver_ip_ = i...
method setDriverPort (line 45) | Expected<void> setDriverPort(uint32_t port) { driver_port_ = port;...
method setSegments (line 47) | Expected<void> setSegments(const std::unordered_set<std::string>& ...
FILE: isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/constant_behavior.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
class ConstantBehavior (line 30) | class ConstantBehavior : public Codelet {
type ConstantBehaviorType (line 41) | enum ConstantBehaviorType {
FILE: isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/entity_count_failure_repeat_controller.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class EntityCountFailureRepeatController (line 28) | class EntityCountFailureRepeatController : public Controller {
FILE: isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/parallel_behavior.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class ParallelBehavior (line 32) | class ParallelBehavior : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/repeat_behavior.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class RepeatBehavior (line 33) | class RepeatBehavior : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/selector_behavior.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class SelectorBehavior (line 34) | class SelectorBehavior : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/sequence_behavior.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class SequenceBehavior (line 35) | class SequenceBehavior : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/switch_behavior.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class SwitchBehavior (line 33) | class SwitchBehavior : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/timer_behavior.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class TimerBehavior (line 32) | class TimerBehavior : public Codelet {
type SwitchStatus (line 49) | enum SwitchStatus {
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/common_expected_macro.hpp
type nvidia::expected_macro (line 164) | namespace nvidia::expected_macro {
type IsStatus (line 168) | struct IsStatus : std::false_type {}
type IsUnwrappable (line 172) | struct IsUnwrappable : std::false_type {}
function IsValid (line 180) | constexpr bool IsValid(const Result& result) {
type StatusType (line 191) | struct StatusType {
type StatusValue (line 199) | struct StatusValue {
method Get (line 200) | static constexpr typename StatusType<Result>::Type Get(const Result&...
type StatusName (line 205) | struct StatusName {
type InvalidUnwrappable (line 211) | struct InvalidUnwrappable {
function GetStatus (line 218) | constexpr typename StatusType<Result>::Type GetStatus(const Result& re...
function GetStatusName (line 223) | std::string GetStatusName(Status status) {
function Unwrappable (line 228) | Unwrappable GetInvalidUnwrappable(Status status) {
class ResultProxy (line 237) | class ResultProxy
method ResultProxy (line 287) | constexpr explicit ResultProxy(Status error) : error_(error) {}
method OtherStatus (line 292) | constexpr OtherStatus castToStatus() const {
method Unwrappable (line 303) | constexpr Unwrappable castToInvalidUnwrappable() const {
class ProxyFactory (line 242) | class ProxyFactory {
method FromUnwrappable (line 250) | static ResultProxy<typename StatusType<Unwrappable>::Type> FromUnwra...
method FromStatusOrUnwrappable (line 259) | static ResultProxy<typename StatusType<Result>::Type> FromStatusOrUn...
class ResultProxy (line 269) | class ResultProxy {
method ResultProxy (line 287) | constexpr explicit ResultProxy(Status error) : error_(error) {}
method OtherStatus (line 292) | constexpr OtherStatus castToStatus() const {
method Unwrappable (line 303) | constexpr Unwrappable castToInvalidUnwrappable() const {
function LogHelper (line 321) | void LogHelper(const char* file, int line, const ExpressionResult& exp...
function LogHelper (line 340) | void LogHelper(const char* file, int line, const ExpressionResult& exp...
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/component.hpp
type nvidia (line 34) | namespace nvidia {
type gxf (line 35) | namespace gxf {
class Component (line 39) | class Component {
method Component (line 43) | Component(const Component& component) = delete;
method Component (line 44) | Component(Component&& component) = delete;
method Component (line 45) | Component& operator=(const Component& component) = delete;
method Component (line 46) | Component& operator=(Component&& component) = delete;
method gxf_result_t (line 59) | virtual gxf_result_t registerInterface(Registrar* registrar) {
method gxf_result_t (line 69) | virtual gxf_result_t initialize() { return GXF_SUCCESS; }
method gxf_result_t (line 73) | virtual gxf_result_t deinitialize() { return GXF_SUCCESS; }
method gxf_context_t (line 75) | gxf_context_t context() const noexcept { return context_; }
method gxf_uid_t (line 76) | gxf_uid_t eid() const noexcept { return eid_; }
method gxf_uid_t (line 77) | gxf_uid_t cid() const noexcept { return cid_; }
method gxf_tid_t (line 78) | gxf_tid_t tid() const noexcept { return tid_; }
method Entity (line 82) | Entity entity() const noexcept {
method internalSetup (line 95) | void internalSetup(gxf_context_t context, gxf_uid_t eid, gxf_uid_t...
method getParameter (line 110) | Expected<T> getParameter(const char* key) {
method setParameter (line 116) | Expected<void> setParameter(const char* key, T value) {
method setParameter (line 123) | Expected<void> setParameter(const char* key, Handle<T>& value) {
method parseParameter (line 129) | Expected<void> parseParameter(const char* key, const YAML::Node& n...
method wrapParameter (line 134) | Expected<YAML::Node> wrapParameter(const char* key) {
method getParametersOfType (line 140) | Expected<std::vector<ParameterRegistrar::ComponentParameterInfo>> ...
method getParameterInfo (line 152) | Expected<ParameterRegistrar::ComponentParameterInfo> getParameterI...
method Component (line 166) | Component() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/entity.hpp
type nvidia (line 30) | namespace nvidia {
type gxf (line 31) | namespace gxf {
class Entity (line 40) | class Entity {
method New (line 51) | static Expected<Entity> New(gxf_context_t context, const char* nam...
method Own (line 70) | static Expected<Entity> Own(gxf_context_t context, gxf_uid_t eid, ...
method Shared (line 87) | static Expected<Entity> Shared(gxf_context_t context, gxf_uid_t ei...
method Entity (line 105) | Entity() = default;
method Entity (line 112) | Entity(const Entity& other) {
method Entity (line 127) | Entity(Entity&& other) {
method Entity (line 142) | Entity& operator=(const Entity& other) {
method Entity (line 166) | Entity& operator=(Entity&& other) {
method activate (line 198) | Expected<void> activate() {
method deactivate (line 207) | Expected<void> deactivate() {
method clone (line 217) | Expected<Entity> clone() const {
method gxf_context_t (line 226) | gxf_context_t context() const { return context_; }
method gxf_uid_t (line 233) | gxf_uid_t eid() const { return eid_; }
method is_null (line 241) | bool is_null() const { return eid_ == kNullUid; }
method add (line 261) | Expected<UntypedHandle> add(gxf_tid_t tid, const char* name = null...
method remove (line 280) | Expected<void> remove(gxf_tid_t tid, const char* name = nullptr) {
method add (line 294) | Expected<Handle<T>> add(const char* name = nullptr) {
method remove (line 319) | Expected<void> remove(const char* name = nullptr) {
method remove (line 336) | Expected<void> remove(gxf_uid_t& cid) {
method get (line 348) | Expected<UntypedHandle> get(gxf_tid_t tid, const char* name = null...
method get (line 369) | Expected<Handle<T>> get(const char* name = nullptr) const {
method findAll (line 396) | Expected<FixedVector<UntypedHandle, N>> findAll() const {
method findAll (line 429) | Expected<FixedVector<Handle<T>, N>> findAll() const {
method findAllHeap (line 466) | Expected<FixedVector<UntypedHandle>> findAllHeap() const {
method findAllHeap (line 499) | Expected<FixedVector<Handle<T>>> findAllHeap() const {
method check_entity_item_ptr (line 543) | Expected<void> check_entity_item_ptr() const {
method release (line 552) | void release() {
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/expected.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
function Unexpected (line 42) | Unexpected ForwardError(const Expected<T>& expected) {
function Unexpected (line 48) | Unexpected ForwardError(Expected<T>&& expected) {
function gxf_result_t (line 55) | gxf_result_t ToResultCode(const Expected<T>& result) {
function ExpectedOrCode (line 61) | inline
function ExpectedOrCode (line 73) | Expected<std::remove_cv_t<std::remove_reference_t<T>>>
function ExpectedOrError (line 83) | Expected<std::remove_cv_t<std::remove_reference_t<T>>>
function gxf_result_t (line 92) | inline
function AccumulateError (line 97) | inline
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/expected_macro.hpp
type nvidia::expected_macro (line 29) | namespace nvidia::expected_macro {
type IsStatus<bool> (line 34) | struct IsStatus<bool> : std::true_type {}
type StatusName<bool> (line 42) | struct StatusName<bool> {
method Get (line 43) | static std::string Get(bool status) { return status ? "Success" : "F...
type IsStatus<int> (line 50) | struct IsStatus<int> : std::true_type {}
type StatusName<int> (line 63) | struct StatusName<int> {
method Get (line 64) | static std::string Get(int status) { return std::to_string(status); }
type StatusName<EnumStatus, typename std::enable_if_t<std::is_enum_v<EnumStatus>>> (line 71) | struct StatusName<EnumStatus, typename std::enable_if_t<std::is_enum_v...
method Get (line 72) | static std::string Get(EnumStatus status) { return std::string(magic...
type IsUnwrappable<std::optional<Value>> (line 79) | struct IsUnwrappable<std::optional<Value>> : std::true_type {}
type StatusType<std::optional<Value>> (line 82) | struct StatusType<std::optional<Value>> {
type StatusValue<std::optional<Value>> (line 87) | struct StatusValue<std::optional<Value>> {
method Get (line 88) | static constexpr bool Get(const std::optional<Value>& optional) { re...
type InvalidUnwrappable<std::optional<Value>, bool> (line 92) | struct InvalidUnwrappable<std::optional<Value>, bool> {
method Get (line 93) | static std::optional<Value> Get(bool status) { return std::nullopt; }
type IsUnwrappable<::nvidia::Expected<Value, Status>> (line 100) | struct IsUnwrappable<::nvidia::Expected<Value, Status>> : std::true_ty...
type StatusType<::nvidia::Expected<Value, Status>> (line 103) | struct StatusType<::nvidia::Expected<Value, Status>> {
type StatusValue<::nvidia::Expected<Value, Status>> (line 108) | struct StatusValue<::nvidia::Expected<Value, Status>> {
method Status (line 109) | static constexpr Status Get(const ::nvidia::Expected<Value, Status>&...
type InvalidUnwrappable<::nvidia::Expected<Value, Status>, Status> (line 115) | struct InvalidUnwrappable<::nvidia::Expected<Value, Status>, Status> {
method Get (line 116) | static ::nvidia::Expected<Value, Status> Get(Status status) {
type IsStatus<gxf_result_t> (line 123) | struct IsStatus<gxf_result_t> : std::true_type {}
function gxf_result_t (line 131) | constexpr gxf_result_t DefaultError<gxf_result_t>() {
type StatusName<gxf_result_t> (line 136) | struct StatusName<gxf_result_t> {
method Get (line 137) | static std::string Get(gxf_result_t status) { return GxfResultStr(st...
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/filepath.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
type FilePath (line 29) | struct FilePath : public std::string {
method FilePath (line 30) | FilePath() : std::string() {}
method FilePath (line 32) | FilePath(const char* s) : std::string(s) {}
method FilePath (line 34) | FilePath(const std::string& str) : std::string(str) {}
type YAML::convert<nvidia::gxf::FilePath> (line 42) | struct YAML::convert<nvidia::gxf::FilePath> {
method Node (line 43) | static Node encode(const nvidia::gxf::FilePath& data) {
method decode (line 48) | static bool decode(const Node& node, nvidia::gxf::FilePath& data) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/gxf.h
type gxf_result_t (line 34) | typedef enum {
type gxf_uid_t (line 136) | typedef int64_t gxf_uid_t;
type gxf_tid_t (line 149) | typedef struct {
function gxf_tid_t (line 159) | inline gxf_tid_t GxfTidNull() {
function GxfTidIsNull (line 170) | inline uint32_t GxfTidIsNull(gxf_tid_t tid) {
type gxf_entity_status_t (line 280) | typedef enum {
type entity_state_t (line 310) | typedef enum {
type gxf_event_t (line 476) | typedef enum {
type gxf_parameter_flags_t_ (line 752) | enum gxf_parameter_flags_t_ {
type gxf_parameter_flags_t (line 770) | typedef uint32_t gxf_parameter_flags_t;
type gxf_runtime_info (line 1035) | typedef struct {
type gxf_extension_info_t (line 1045) | typedef struct {
type gxf_component_info_t (line 1069) | typedef struct {
type gxf_parameter_type_t (line 1089) | typedef enum {
type gxf_parameter_info_t (line 1111) | typedef struct {
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/gxf_ext.h
type GxfFlags (line 33) | typedef uint32_t GxfFlags;
type GxfLoadExtensionsInfo (line 38) | typedef struct {
type GxfEntityCreateFlagBits (line 103) | typedef enum GxfEntityCreateFlagBits {
type GxfFlags (line 113) | typedef GxfFlags GxfEntityCreateFlags;
type GxfEntityCreateInfo (line 116) | typedef struct {
type gxf_severity_t (line 255) | typedef enum {
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/handle.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class UntypedHandle (line 32) | class UntypedHandle {
method UntypedHandle (line 34) | UntypedHandle(const UntypedHandle& component) = default;
method UntypedHandle (line 35) | UntypedHandle(UntypedHandle&& component) = default;
method UntypedHandle (line 36) | UntypedHandle& operator=(const UntypedHandle& component) = default;
method UntypedHandle (line 37) | UntypedHandle& operator=(UntypedHandle&& component) = default;
method UntypedHandle (line 40) | static UntypedHandle Null() {
method Create (line 45) | static Expected<UntypedHandle> Create(gxf_context_t context, gxf_u...
method Create (line 60) | static Expected<UntypedHandle> Create(gxf_context_t context, gxf_u...
method gxf_context_t (line 66) | gxf_context_t context() const { return context_; }
method gxf_uid_t (line 68) | gxf_uid_t cid() const { return cid_; }
method gxf_tid_t (line 70) | gxf_tid_t tid() const { return tid_; }
method is_null (line 74) | bool is_null() const {
method UntypedHandle (line 87) | UntypedHandle(gxf_context_t context, gxf_uid_t cid)
method UntypedHandle (line 90) | UntypedHandle(gxf_context_t context, gxf_uid_t cid, gxf_tid_t tid,...
method initialize (line 93) | Expected<void> initialize(gxf_tid_t tid) {
method initialize (line 101) | Expected<void> initialize(const char* type_name) {
method verifyPointer (line 110) | Expected<void> verifyPointer() const {
class Handle (line 136) | class Handle : public UntypedHandle {
method Handle (line 139) | static Handle Null() {
method Handle (line 149) | static Handle Unspecified() {
method Create (line 154) | static Expected<Handle> Create(gxf_context_t context, gxf_uid_t ci...
method Create (line 163) | static Expected<Handle> Create(gxf_context_t context, gxf_uid_t cid,
method Create (line 173) | static Expected<Handle> Create(const UntypedHandle& untyped_handle) {
method Handle (line 190) | Handle(gxf_context_t context = kNullContext, gxf_uid_t uid = kNull...
method Handle (line 193) | Handle(gxf_context_t context , gxf_uid_t uid , gxf_tid_t tid, void...
method Handle (line 198) | Handle(const Handle& component) = default;
method Handle (line 199) | Handle(Handle&& component) = default;
method Handle (line 200) | Handle& operator=(const Handle& component) = default;
method Handle (line 201) | Handle& operator=(Handle&& component) = default;
method Handle (line 204) | Handle(const Handle<Derived>& derived) : UntypedHandle(derived) {
method T (line 212) | T* operator->() const {
method T (line 216) | T* get() const {
method try_get (line 225) | Expected<T*> try_get() const {
function CreateHandleFromString (line 244) | static Expected<Handle<T>> CreateHandleFromString(gxf_context_t cont...
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/parameter.hpp
type nvidia (line 33) | namespace nvidia {
type gxf (line 34) | namespace gxf {
class ParameterBackendBase (line 37) | class ParameterBackendBase {
method gxf_context_t (line 42) | gxf_context_t context() const { return context_; }
method gxf_uid_t (line 45) | gxf_uid_t uid() const { return uid_; }
method isMandatory (line 52) | bool isMandatory() const { return (flags_ & GXF_PARAMETER_FLAGS_OP...
method isConstant (line 55) | bool isConstant() const { return (flags_ & GXF_PARAMETER_FLAGS_DYN...
method isImmutable (line 70) | bool isImmutable() const {
class Parameter (line 91) | class Parameter
method Parameter (line 215) | Parameter() = default;
method Parameter (line 218) | Parameter(const Parameter<T>& other)
method T (line 226) | const T& get() const {
method set (line 248) | Expected<void> set(T value) {
method setWithoutPropagate (line 261) | void setWithoutPropagate(const T& value) {
method connect (line 267) | void connect(ParameterBackend<T>* backend) {
class ParameterBackend (line 95) | class ParameterBackend : public ParameterBackendBase {
method isAvailable (line 99) | bool isAvailable() const override { return value_.has_value(); }
method set (line 102) | Expected<void> set(T value) {
method wrap (line 112) | Expected<YAML::Node> wrap() {
class HandleParameterBackend (line 129) | class HandleParameterBackend : public ParameterBackendBase {
class ParameterBackend<Handle<T>> (line 144) | class ParameterBackend<Handle<T>> : public HandleParameterBackend {
method isAvailable (line 148) | bool isAvailable() const override {
method wrap (line 152) | Expected<YAML::Node> wrap() {
method set (line 161) | Expected<void> set(gxf_uid_t cid) override {
method get (line 172) | Expected<gxf_uid_t> get() const override {
method set (line 184) | Expected<void> set(Handle<T> value) {
class ParameterBase (line 205) | class ParameterBase {
class Parameter (line 213) | class Parameter : public ParameterBase {
method Parameter (line 215) | Parameter() = default;
method Parameter (line 218) | Parameter(const Parameter<T>& other)
method T (line 226) | const T& get() const {
method set (line 248) | Expected<void> set(T value) {
method setWithoutPropagate (line 261) | void setWithoutPropagate(const T& value) {
method connect (line 267) | void connect(ParameterBackend<T>* backend) {
class Parameter<Handle<S>> (line 283) | class Parameter<Handle<S>> : public ParameterBase {
method S (line 311) | S* operator->() const {
method set (line 316) | Expected<void> set(Handle<S> value) {
method setWithoutPropagate (line 330) | void setWithoutPropagate(const Handle<S>& value) {
method connect (line 335) | void connect(ParameterBackend<Handle<S>>* backend) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/parameter_parser.hpp
type nvidia (line 34) | namespace nvidia {
type gxf (line 35) | namespace gxf {
type ParameterParser (line 38) | struct ParameterParser
type ParameterParser<T> (line 43) | struct ParameterParser<T> {
method Parse (line 44) | static Expected<T> Parse(gxf_context_t context, gxf_uid_t componen...
type ParameterParser<std::string> (line 65) | struct ParameterParser<std::string> {
method Parse (line 66) | static Expected<std::string> Parse(gxf_context_t context, gxf_uid_...
type ParameterParser<FilePath> (line 83) | struct ParameterParser<FilePath> {
method Parse (line 84) | static Expected<FilePath> Parse(gxf_context_t context, gxf_uid_t c...
type ParameterParser<uint8_t> (line 104) | struct ParameterParser<uint8_t> {
method Parse (line 105) | static Expected<uint8_t> Parse(gxf_context_t context, gxf_uid_t co...
type ParameterParser<FixedString<N>> (line 122) | struct ParameterParser<FixedString<N>> {
method Parse (line 123) | static Expected<FixedString<N>> Parse(gxf_context_t context, gxf_u...
type ParameterParser<FixedVector<T, N>> (line 140) | struct ParameterParser<FixedVector<T, N>> {
method Parse (line 141) | static Expected<FixedVector<T, N>> Parse(gxf_context_t context, gx...
type ParameterParser<Handle<S>> (line 167) | struct ParameterParser<Handle<S>> {
method Parse (line 168) | static Expected<Handle<S>> Parse(gxf_context_t context, gxf_uid_t ...
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/parameter_parser_std.hpp
type nvidia (line 37) | namespace nvidia {
type gxf (line 38) | namespace gxf {
type ParameterParser<std::vector<T>> (line 42) | struct ParameterParser<std::vector<T>> {
method Parse (line 43) | static Expected<std::vector<T>> Parse(gxf_context_t context, gxf_u...
type ParameterParser<std::array<T, N>> (line 66) | struct ParameterParser<std::array<T, N>> {
method Parse (line 67) | static Expected<std::array<T, N>> Parse(gxf_context_t context, gxf...
type ParameterParser<std::unordered_map<std::string, T>> (line 93) | struct ParameterParser<std::unordered_map<std::string, T>> {
method Parse (line 94) | static Expected<std::unordered_map<std::string, T>> Parse(gxf_cont...
type ParameterParser<std::complex<T>> (line 120) | struct ParameterParser<std::complex<T>> {
method Parse (line 121) | static Expected<std::complex<T>> Parse(gxf_context_t context, gxf_...
type ParameterInfoOverride<std::vector<T>> (line 141) | struct ParameterInfoOverride<std::vector<T>> {
method apply (line 142) | Expected<void> apply(ParameterRegistrar* registrar,
type ParameterInfoOverride<std::array<T, N>> (line 167) | struct ParameterInfoOverride<std::array<T, N>> {
method apply (line 168) | Expected<void> apply(ParameterRegistrar* registrar,
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/parameter_registrar.hpp
type nvidia (line 37) | namespace nvidia {
type gxf (line 38) | namespace gxf {
type ParameterInfo (line 42) | struct ParameterInfo {
class Component (line 70) | class Component
type ParameterTypeTrait (line 73) | struct ParameterTypeTrait {
type ParameterTypeTrait<Handle<T>> (line 80) | struct ParameterTypeTrait<Handle<T>> {
type ParameterTypeTrait<int8_t> (line 87) | struct ParameterTypeTrait<int8_t> {
type ParameterTypeTrait<int16_t> (line 94) | struct ParameterTypeTrait<int16_t> {
type ParameterTypeTrait<int32_t> (line 101) | struct ParameterTypeTrait<int32_t> {
type ParameterTypeTrait<int64_t> (line 108) | struct ParameterTypeTrait<int64_t> {
type ParameterTypeTrait<uint8_t> (line 115) | struct ParameterTypeTrait<uint8_t> {
type ParameterTypeTrait<uint16_t> (line 122) | struct ParameterTypeTrait<uint16_t> {
type ParameterTypeTrait<uint32_t> (line 129) | struct ParameterTypeTrait<uint32_t> {
type ParameterTypeTrait<uint64_t> (line 136) | struct ParameterTypeTrait<uint64_t> {
type ParameterTypeTrait<float> (line 143) | struct ParameterTypeTrait<float> {
type ParameterTypeTrait<double> (line 150) | struct ParameterTypeTrait<double> {
type ParameterTypeTrait<char*> (line 157) | struct ParameterTypeTrait<char*> {
type ParameterTypeTrait<std::string> (line 164) | struct ParameterTypeTrait<std::string> {
type ParameterTypeTrait<bool> (line 171) | struct ParameterTypeTrait<bool> {
type ParameterTypeTrait<FilePath> (line 178) | struct ParameterTypeTrait<FilePath> {
type ParameterTypeTrait<std::complex<float>> (line 185) | struct ParameterTypeTrait<std::complex<float>> {
type ParameterTypeTrait<std::complex<double>> (line 192) | struct ParameterTypeTrait<std::complex<double>> {
class ParameterRegistrar (line 199) | class ParameterRegistrar {
class TypeEraser (line 203) | class TypeEraser {
method TypeEraser (line 205) | TypeEraser() = default;
method TypeEraser (line 206) | TypeEraser(const TypeEraser& other) { *this = other; }
method TypeEraser (line 207) | TypeEraser(TypeEraser&& other) { *this = std::move(other); }
method TypeEraser (line 209) | TypeEraser(T&& value) { *this = std::forward<T>(value); }
method TypeEraser (line 212) | TypeEraser& operator=(const TypeEraser& other) {
method TypeEraser (line 219) | TypeEraser& operator=(TypeEraser&& other) {
method has_value (line 230) | bool has_value() const { return static_cast<bool>(instance_); }
method reset (line 232) | void reset() { instance_.reset(); }
type storage_base (line 235) | struct storage_base {
type storage_impl (line 242) | struct storage_impl final : public storage_base {
method storage_impl (line 244) | storage_impl(Args&&... args) : value(std::forward<Args>(args)....
method clone (line 249) | std::unique_ptr<storage_base> clone() const override {
type ComponentParameterInfo (line 260) | struct ComponentParameterInfo {
type ComponentInfo (line 284) | struct ComponentInfo {
method ParameterRegistrar (line 290) | ParameterRegistrar() = default;
method tidFromTypename (line 338) | Expected<gxf_tid_t> tidFromTypename(std::string type_name) {
function getNumericRangeImpl (line 362) | static bool getNumericRangeImpl(ParameterRegistrar::ComponentParamet...
type ParameterInfoOverride (line 390) | struct ParameterInfoOverride {
method apply (line 391) | Expected<void> apply(ParameterRegistrar* /*registrar*/,
type ParameterInfoOverride<Handle<T>> (line 402) | struct ParameterInfoOverride<Handle<T>> {
method apply (line 403) | Expected<void> apply(ParameterRegistrar* registrar,
type ParameterQueryOverride (line 486) | struct ParameterQueryOverride {
method query (line 487) | Expected<std::vector<ParameterRegistrar::ComponentParameterInfo>> ...
type ParameterQueryOverride<Handle<T>> (line 506) | struct ParameterQueryOverride<Handle<T>> {
method query (line 507) | Expected<std::vector<ParameterRegistrar::ComponentParameterInfo>> ...
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/parameter_storage.hpp
type nvidia (line 30) | namespace nvidia {
type gxf (line 31) | namespace gxf {
class ParameterStorage (line 37) | class ParameterStorage {
method registerParameter (line 44) | Expected<void> registerParameter(nvidia::gxf::Parameter<T>* fronte...
method set (line 95) | Expected<void> set(gxf_uid_t uid, const char* key, T value) {
method get (line 135) | Expected<T> get(gxf_uid_t uid, const char* key) const {
method getValuePointer (line 183) | Expected<const T*> getValuePointer(gxf_uid_t uid, const char* key)...
method getBackendPointerImpl (line 194) | Expected<const T*> getBackendPointerImpl(gxf_uid_t uid, const char...
method getBackendPointerImpl (line 207) | Expected<T*> getBackendPointerImpl(gxf_uid_t uid, const char* key) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/parameter_wrapper.hpp
type nvidia (line 31) | namespace nvidia {
type gxf (line 32) | namespace gxf {
type ParameterWrapper (line 35) | struct ParameterWrapper
type ParameterWrapper<T> (line 38) | struct ParameterWrapper<T> {
method Wrap (line 40) | static Expected<YAML::Node> Wrap(gxf_context_t context, const T& v...
type ParameterWrapper<Handle<T>> (line 46) | struct ParameterWrapper<Handle<T>> {
method Wrap (line 47) | static Expected<YAML::Node> Wrap(gxf_context_t context, const Hand...
type ParameterWrapper<std::vector<nvidia::gxf::Handle<T>>> (line 68) | struct ParameterWrapper<std::vector<nvidia::gxf::Handle<T>>> {
method Wrap (line 69) | static Expected<YAML::Node> Wrap(
type ParameterWrapper<std::array<nvidia::gxf::Handle<T>, N>> (line 85) | struct ParameterWrapper<std::array<nvidia::gxf::Handle<T>, N>> {
method Wrap (line 86) | static Expected<YAML::Node> Wrap(
type ParameterWrapper<std::unordered_map<std::string, T>> (line 102) | struct ParameterWrapper<std::unordered_map<std::string, T>> {
method Wrap (line 103) | static Expected<YAML::Node> Wrap(
type ParameterWrapper<nvidia::FixedVector<T, N>> (line 121) | struct ParameterWrapper<nvidia::FixedVector<T, N>> {
method Wrap (line 122) | static Expected<YAML::Node> Wrap(
type ParameterWrapper<nvidia::FixedString<N>> (line 139) | struct ParameterWrapper<nvidia::FixedString<N>> {
method Wrap (line 140) | static Expected<YAML::Node> Wrap(
type ParameterWrapper<nvidia::FixedVector<nvidia::gxf::Handle<T>, N>> (line 148) | struct ParameterWrapper<nvidia::FixedVector<nvidia::gxf::Handle<T>, ...
method Wrap (line 149) | static Expected<YAML::Node> Wrap(
type ParameterWrapper<nvidia::gxf::FilePath> (line 166) | struct ParameterWrapper<nvidia::gxf::FilePath> {
method Wrap (line 167) | static Expected<YAML::Node> Wrap(
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/registrar.hpp
type nvidia (line 34) | namespace nvidia {
type gxf (line 35) | namespace gxf {
class Registrar (line 38) | class Registrar {
method Unexpected (line 41) | static constexpr Unexpected NoDefaultParameter() {
method Registrar (line 45) | Registrar() = default;
method parameter (line 49) | Expected<void> parameter(Parameter<T>& parameter, const char* key) {
method parameter (line 55) | Expected<void> parameter(Parameter<T>& parameter, const char* key,...
method parameter (line 61) | Expected<void> parameter(Parameter<T>& parameter, const char* key,...
method parameter (line 68) | Expected<void> parameter(Parameter<T>& parameter, const char* key,...
method parameter (line 81) | Expected<void> parameter(Parameter<T>& parameter, const char* key,...
method parameter (line 96) | Expected<void> parameter(Parameter<T>& parameter, const char* key,...
method parameter (line 108) | Expected<void> parameter(nvidia::gxf::Parameter<T>& parameter,
method parameterImpl (line 124) | Expected<void> parameterImpl(nvidia::gxf::Parameter<T>& parameter,
method registerParameterlessComponent (line 139) | Expected<void> registerParameterlessComponent() {
method resource (line 152) | Expected<void> resource(Resource<Handle<T>>& resource, const char*...
method setParameterStorage (line 172) | void setParameterStorage(std::shared_ptr<ParameterStorage> param_s...
method ParameterStorage (line 177) | ParameterStorage* getParameterStorage() { return parameter_storage...
method setParameterRegistrar (line 180) | void setParameterRegistrar(ParameterRegistrar* param_registrar) {
method ParameterRegistrar (line 185) | ParameterRegistrar* getParameterRegistrar() { return parameter_reg...
method setResourceRegistrar (line 188) | void setResourceRegistrar(std::shared_ptr<ResourceRegistrar> resou...
method setResourceManager (line 193) | void setResourceManager(std::shared_ptr<ResourceManager> resource_...
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/resource.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class Resource (line 31) | class Resource
class Resource<Handle<T>> (line 34) | class Resource<Handle<T>> {
method connect (line 64) | Expected<void> connect(std::shared_ptr<ResourceManager> resource_m...
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/resource_manager.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class ResourceManager (line 31) | class ResourceManager {
method findEntityResource (line 50) | static Expected<Handle<T>> findEntityResource(gxf_context_t contex...
method findEntityResource (line 62) | Expected<Handle<T>> findEntityResource(gxf_uid_t eid,
method findComponentResource (line 71) | Expected<Handle<T>> findComponentResource(gxf_uid_t cid,
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/resource_registrar.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class ResourceRegistrar (line 30) | class ResourceRegistrar {
method ResourceRegistrar (line 32) | ResourceRegistrar(gxf_context_t context) : context_(context) {}
type ComponentResourceInfo (line 34) | struct ComponentResourceInfo {
type ComponentInfo (line 40) | struct ComponentInfo {
method registerComponentResource (line 46) | Expected<void> registerComponentResource(gxf_tid_t comp_tid,
FILE: isaac_ros_gxf/gxf/core/include/gxf/core/type_registry.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class TypeRegistry (line 32) | class TypeRegistry {
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_allocator.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
class CudaAllocator (line 31) | class CudaAllocator : public Allocator {
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_buffer.hpp
type nvidia (line 33) | namespace nvidia {
type gxf (line 34) | namespace gxf {
class CudaBuffer (line 45) | class CudaBuffer : public MemoryBuffer {
type State (line 48) | enum class State : int8_t {
method CudaBuffer (line 54) | CudaBuffer() = default;
method CudaBuffer (line 55) | CudaBuffer(const CudaBuffer&) = delete;
method CudaBuffer (line 56) | CudaBuffer& operator=(const CudaBuffer&) = delete;
method CudaBuffer (line 58) | CudaBuffer(CudaBuffer&& other) noexcept { *this = std::move(other); }
method CudaBuffer (line 60) | CudaBuffer& operator=(CudaBuffer&& other) noexcept {
method cudaHostCallback (line 82) | static void CUDART_CB cudaHostCallback(void* buffer_ptr) {
method freeBuffer (line 89) | Expected<void> freeBuffer() {
method resizeAsync (line 109) | Expected<void> resizeAsync(Handle<CudaAllocator> allocator,
method State (line 169) | State state() const { return state_.load(); }
method stream (line 172) | Handle<CudaStream> stream() {
method streamPool (line 177) | Handle<CudaStreamPool> streamPool() {
method transferStreamOwnership (line 183) | Handle<CudaStream> transferStreamOwnership() {
method registerCallbackOnStream (line 189) | Expected<void> registerCallbackOnStream(callback_function_t func, ...
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_event.hpp
type nvidia (line 29) | namespace nvidia {
type gxf (line 30) | namespace gxf {
class CudaStream (line 32) | class CudaStream
class CudaEvent (line 38) | class CudaEvent {
method CudaEvent (line 40) | CudaEvent() = default;
method CudaEvent (line 43) | CudaEvent(const CudaEvent&) = delete;
method CudaEvent (line 45) | CudaEvent(CudaEvent&& other) {
method dev_id (line 73) | int dev_id() const { return dev_id_; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_scheduling_terms.hpp
type nvidia (line 36) | namespace nvidia {
type gxf (line 37) | namespace gxf {
class CudaStreamSchedulingTerm (line 47) | class CudaStreamSchedulingTerm : public SchedulingTerm {
type State (line 50) | enum class State : int8_t {
class CudaEventSchedulingTerm (line 83) | class CudaEventSchedulingTerm : public SchedulingTerm {
class CudaBufferAvailableSchedulingTerm (line 106) | class CudaBufferAvailableSchedulingTerm : public SchedulingTerm {
type State (line 109) | enum class State : int8_t {
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream.hpp
type nvidia (line 35) | namespace nvidia {
type gxf (line 36) | namespace gxf {
class CudaStream (line 42) | class CudaStream {
method CudaStream (line 44) | CudaStream() = default;
method CudaStream (line 47) | CudaStream(const CudaStream&) = delete;
method CudaStream (line 48) | CudaStream(CudaStream&&) = delete;
method dev_id (line 57) | int dev_id() const { return dev_id_; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_id.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
type CudaStreamId (line 33) | struct CudaStreamId {
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_pool.hpp
type nvidia (line 37) | namespace nvidia {
type gxf (line 38) | namespace gxf {
class CudaStreamPool (line 43) | class CudaStreamPool : public Allocator {
method CudaStreamPool (line 45) | CudaStreamPool() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_sync.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class CudaStreamSync (line 35) | class CudaStreamSync : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/stream_ordered_allocator.hpp
type nvidia (line 33) | namespace nvidia {
type gxf (line 34) | namespace gxf {
class StreamOrderedAllocator (line 43) | class StreamOrderedAllocator : public CudaAllocator {
method StreamOrderedAllocator (line 45) | StreamOrderedAllocator() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/tests/green_context_with_smid.h
type SmidThreadInfo (line 31) | struct SmidThreadInfo {
FILE: isaac_ros_gxf/gxf/core/include/gxf/cuda/tests/test_cuda_helper.hpp
type nvidia (line 58) | namespace nvidia {
type gxf (line 59) | namespace gxf {
type test (line 60) | namespace test {
type cuda (line 61) | namespace cuda {
class StreamBasedOps (line 68) | class StreamBasedOps : public Codelet {
method getStream (line 70) | static Expected<Handle<CudaStream>> getStream(Entity& message) {
method addStream (line 80) | static Expected<void> addStream(Entity& message, Handle<CudaSt...
method addTensor (line 89) | static Expected<Handle<Tensor>> addTensor(Entity& message, Han...
method addNewEvent (line 105) | Expected<Handle<CudaEvent>> addNewEvent(Entity& message, const...
method initOpsEvent (line 117) | Expected<void> initOpsEvent() {
class StreamTensorGenerator (line 142) | class StreamTensorGenerator : public StreamBasedOps {
method gxf_result_t (line 144) | gxf_result_t initialize() override {
method gxf_result_t (line 153) | gxf_result_t deinitialize() override {
method gxf_result_t (line 158) | gxf_result_t tick() override {
method gxf_result_t (line 191) | gxf_result_t registerInterface(Registrar* registrar) override {
method createTensors (line 203) | Expected<void> createTensors(Entity& dev_msg, Entity& host_msg) {
class DotProductExe (line 244) | class DotProductExe {
method DotProductExe (line 251) | DotProductExe() = default;
method setEnv (line 253) | void setEnv(const Handle<Receiver>& rx, const Handle<Transmitt...
method execute (line 263) | Expected<void> execute(const char* out_tensor_name = "") {
class CublasDotProduct (line 306) | class CublasDotProduct : public StreamBasedOps {
class CublasDotProductExe (line 309) | class CublasDotProductExe : public DotProductExe {
method CublasDotProductExe (line 315) | CublasDotProductExe(CublasDotProduct* codelet) : codelet_(co...
method dotproduct_i (line 319) | Expected<void> dotproduct_i(float* in0, float* in1, float* o...
method CublasDotProduct (line 356) | CublasDotProduct() : exec_(this) {}
method gxf_result_t (line 358) | gxf_result_t initialize() override {
method gxf_result_t (line 364) | gxf_result_t start() override { return ToResultCode(initOpsEve...
method gxf_result_t (line 366) | gxf_result_t tick() override {
method gxf_result_t (line 371) | gxf_result_t registerInterface(Registrar* registrar) override {
class HostDotProduct (line 388) | class HostDotProduct : public Codelet {
class HostDotProductExe (line 391) | class HostDotProductExe : public DotProductExe {
method HostDotProductExe (line 393) | HostDotProductExe() = default;
method dotproduct_i (line 395) | Expected<void> dotproduct_i(float* in0, float* in1, float* o...
method gxf_result_t (line 408) | gxf_result_t initialize() override {
method gxf_result_t (line 414) | gxf_result_t tick() override {
method gxf_result_t (line 419) | gxf_result_t registerInterface(Registrar* registrar) override {
class MemCpy2Host (line 436) | class MemCpy2Host : public StreamBasedOps {
method gxf_result_t (line 438) | gxf_result_t start() override { return ToResultCode(initOpsEve...
method gxf_result_t (line 440) | gxf_result_t tick() override {
method gxf_result_t (line 488) | gxf_result_t registerInterface(Registrar* registrar) override {
class VerifyEqual (line 503) | class VerifyEqual : public Codelet {
method gxf_result_t (line 505) | gxf_result_t tick() override {
method gxf_result_t (line 541) | gxf_result_t registerInterface(Registrar* registrar) override {
method fequal (line 549) | bool fequal(float a, float b) {
class CudaAsyncBufferGenerator (line 561) | class CudaAsyncBufferGenerator : public Codelet {
method gxf_result_t (line 565) | gxf_result_t registerInterface(Registrar* registrar) override {
method gxf_result_t (line 578) | gxf_result_t tick() override {
class GreenContextWithSmid (line 626) | class GreenContextWithSmid: public Codelet {
method gxf_result_t (line 630) | gxf_result_t registerInterface(Registrar* registrar) override {
method gxf_result_t (line 640) | gxf_result_t start() override {
method gxf_result_t (line 651) | gxf_result_t stop() override {
method gxf_result_t (line 658) | gxf_result_t tick() override {
class Convolve2D (line 673) | class Convolve2D: public Codelet {
method gxf_result_t (line 677) | gxf_result_t registerInterface(Registrar* registrar) override {
method gxf_result_t (line 690) | gxf_result_t start() override {
method gxf_result_t (line 722) | gxf_result_t stop() override {
method gxf_result_t (line 727) | gxf_result_t tick() override {
type callBackData (line 733) | struct callBackData {
method cudaEntityFreeCallback (line 738) | static void CUDART_CB cudaEntityFreeCallback(void* data_ptr) {
method _tick (line 751) | Expected<void> _tick() {
class CudaBufferRx (line 824) | class CudaBufferRx: public Codelet {
method gxf_result_t (line 828) | gxf_result_t registerInterface(Registrar* registrar) override {
method gxf_result_t (line 835) | gxf_result_t tick() override {
class CudaSMCount (line 863) | class CudaSMCount : public Codelet {
method gxf_result_t (line 865) | gxf_result_t initialize() override {
method gxf_result_t (line 870) | gxf_result_t tick() override {
method gxf_result_t (line 912) | gxf_result_t deinitialize() override {
method gxf_result_t (line 922) | gxf_result_t registerInterface(Registrar* registrar) override {
FILE: isaac_ros_gxf/gxf/core/include/gxf/logger/gxf_logger.hpp
type nvidia (line 26) | namespace nvidia {
type Severity (line 32) | enum class Severity {
type SeverityContainer (line 49) | struct SeverityContainer {
type logger (line 57) | namespace logger {
class GxfLogger (line 70) | class GxfLogger : public Logger {
class GlobalGxfLogger (line 87) | class GlobalGxfLogger {
FILE: isaac_ros_gxf/gxf/core/include/gxf/logger/logger.hpp
type nvidia (line 28) | namespace nvidia {
type logger (line 31) | namespace logger {
class ILogger (line 41) | class ILogger {
class Logger (line 167) | class Logger {
method Logger (line 170) | Logger() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/multimedia/audio.hpp
type nvidia (line 31) | namespace nvidia {
type gxf (line 32) | namespace gxf {
type AudioFormat (line 35) | enum class AudioFormat {
type AudioLayout (line 42) | enum class AudioLayout {
type AudioTypeTraits (line 49) | struct AudioTypeTraits
type AudioBufferInfo (line 64) | struct AudioBufferInfo {
class AudioBuffer (line 82) | class AudioBuffer {
method AudioBuffer (line 84) | AudioBuffer() = default;
method AudioBuffer (line 88) | AudioBuffer(const AudioBuffer&) = delete;
method AudioBuffer (line 90) | AudioBuffer(AudioBuffer&& other) { *this = std::move(other); }
method AudioBuffer (line 92) | AudioBuffer& operator=(const AudioBuffer&) = delete;
method AudioBuffer (line 94) | AudioBuffer& operator=(AudioBuffer&& other) {
method resize (line 102) | Expected<void> resize(uint32_t channels, uint32_t samples, uint32_...
method AudioBufferInfo (line 123) | AudioBufferInfo audio_buffer_info() const { return buffer_info_; }
method MemoryStorageType (line 126) | MemoryStorageType storage_type() const { return memory_buffer_.sto...
method size (line 129) | uint64_t size() const { return memory_buffer_.size(); }
method byte (line 132) | byte* pointer() const { return memory_buffer_.pointer(); }
FILE: isaac_ros_gxf/gxf/core/include/gxf/multimedia/camera.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
type Vector2 (line 30) | struct Vector2 {
type DistortionType (line 39) | enum class DistortionType {
type CameraModelBase (line 110) | struct CameraModelBase {
type Pose3DBase (line 138) | struct Pose3DBase {
FILE: isaac_ros_gxf/gxf/core/include/gxf/multimedia/video.hpp
type nvidia (line 32) | namespace nvidia {
type gxf (line 33) | namespace gxf {
function StrideAlign (line 42) | static constexpr uint32_t StrideAlign(uint32_t stride) {
function ComputeStrides (line 51) | static constexpr uint32_t ComputeStrides(bool stride_align, uint32_t...
function AlignToEvenDimension (line 67) | static constexpr uint32_t AlignToEvenDimension(uint32_t value) {
type VideoFormat (line 72) | enum class VideoFormat : std::int64_t {
type SurfaceLayout (line 123) | enum class SurfaceLayout : std::int32_t {
type VideoTypeTraits (line 130) | struct VideoTypeTraits
type ColorPlane (line 189) | struct ColorPlane {
method ColorPlane (line 198) | ColorPlane() {}
method ColorPlane (line 199) | ColorPlane(const char* c_space, uint8_t c_depth, uint32_t c_stride...
type VideoFormatSize (line 206) | struct VideoFormatSize {
method size (line 207) | uint64_t size(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 210) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_YUV420 ||
T == VideoFormat::GXF_VIDEO_FORMAT_YUV420_ER ||
T == VideoFormat::GXF_VIDEO_FORMAT_YUV420_709 ||
T == VideoFormat::GXF_VIDEO_FORMAT_YUV420_709_ER>> (line 216) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method fillColorPlanes (line 222) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 250) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 258) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 263) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_NV24 ||
T == VideoFormat::GXF_VIDEO_FORMAT_NV24_ER>> (line 270) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method fillColorPlanes (line 274) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 293) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 301) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 306) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_NV12 ||
T == VideoFormat::GXF_VIDEO_FORMAT_NV12_ER ||
T == VideoFormat::GXF_VIDEO_FORMAT_NV12_709 ||
T == VideoFormat::GXF_VIDEO_FORMAT_NV12_709_ER>> (line 313) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method fillColorPlanes (line 319) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 340) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 348) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 353) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<
T, std::enable_if_t<
T == VideoFormat::GXF_VIDEO_FORMAT_RGBA || T == VideoFormat::GXF_VIDEO_FORMAT_BGRA ||
T == VideoFormat::GXF_VIDEO_FORMAT_ARGB || T == VideoFormat::GXF_VIDEO_FORMAT_ABGR ||
T == VideoFormat::GXF_VIDEO_FORMAT_RGBX || T == VideoFormat::GXF_VIDEO_FORMAT_BGRX ||
T == VideoFormat::GXF_VIDEO_FORMAT_XRGB || T == VideoFormat::GXF_VIDEO_FORMAT_XBGR>> (line 360) | struct VideoFormatSize<
method defaultRGBA (line 366) | std::array<ColorPlane, 1> defaultRGBA() {
method fillColorPlanes (line 386) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 400) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 408) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 413) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<
T, std::enable_if_t<
T == VideoFormat::GXF_VIDEO_FORMAT_RGB || T == VideoFormat::GXF_VIDEO_FORMAT_BGR ||
T == VideoFormat::GXF_VIDEO_FORMAT_RGB16 || T == VideoFormat::GXF_VIDEO_FORMAT_BGR16 ||
T == VideoFormat::GXF_VIDEO_FORMAT_RGB32 || T == VideoFormat::GXF_VIDEO_FORMAT_BGR32>> (line 421) | struct VideoFormatSize<
method defaultRGB (line 426) | std::array<ColorPlane, 1> defaultRGB() {
method fillColorPlanes (line 442) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 456) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 464) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 469) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8 ||
T == VideoFormat::GXF_VIDEO_FORMAT_B8_G8_R8 ||
T == VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16 ||
T == VideoFormat::GXF_VIDEO_FORMAT_B16_G16_R16 ||
T == VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32 ||
T == VideoFormat::GXF_VIDEO_FORMAT_B32_G32_R32>> (line 477) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method defaultRGB (line 483) | std::array<ColorPlane, 3> defaultRGB() {
method fillColorPlanes (line 499) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 518) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 526) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 531) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8_D8 ||
T == VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16_D16 ||
T == VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32_D32>> (line 539) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method defaultRGBD (line 542) | std::array<ColorPlane, 4> defaultRGBD() {
method fillColorPlanes (line 552) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 571) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 579) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 584) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_RGBD8 ||
T == VideoFormat::GXF_VIDEO_FORMAT_RGBD16 ||
T == VideoFormat::GXF_VIDEO_FORMAT_RGBD32>> (line 592) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method defaultRGBD (line 595) | std::array<ColorPlane, 1> defaultRGBD() {
method fillColorPlanes (line 605) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 620) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 628) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 633) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_D32F ||
T == VideoFormat::GXF_VIDEO_FORMAT_D64F >> (line 641) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method defaultDepth (line 643) | std::array<ColorPlane, 1> defaultDepth() {
method fillColorPlanes (line 651) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 666) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 674) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 679) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_GRAY ||
T == VideoFormat::GXF_VIDEO_FORMAT_GRAY16 ||
T == VideoFormat::GXF_VIDEO_FORMAT_GRAY32 ||
T == VideoFormat::GXF_VIDEO_FORMAT_GRAY32F>> (line 688) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method defaultGray (line 692) | std::array<ColorPlane, 1> defaultGray() {
method fillColorPlanes (line 702) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 716) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 724) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 729) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VIDEO_FORMAT_RAW16_RGGB ||
T == VideoFormat::GXF_VIDEO_FORMAT_RAW16_BGGR ||
T == VideoFormat::GXF_VIDEO_FORMAT_RAW16_GRBG ||
T == VideoFormat::GXF_VIDEO_FORMAT_RAW16_GBRG>> (line 737) | struct VideoFormatSize<T, std::enable_if_t<T == VideoFormat::GXF_VID...
method defaultBayerRaw16 (line 741) | std::array<ColorPlane, 1> defaultBayerRaw16() {
method fillColorPlanes (line 753) | uint64_t fillColorPlanes(uint32_t width, uint32_t height,
method getDefaultColorPlanes (line 767) | std::vector<ColorPlane> getDefaultColorPlanes(uint32_t width, uint...
method size (line 775) | uint64_t size(uint32_t width, uint32_t height, std::array<ColorPla...
method size (line 780) | uint64_t size(uint32_t width, uint32_t height, bool stride_align =...
type VideoBufferInfo (line 787) | struct VideoBufferInfo {
class VideoBuffer (line 803) | class VideoBuffer {
method VideoBuffer (line 805) | VideoBuffer() = default;
method VideoBuffer (line 809) | VideoBuffer(const VideoBuffer&) = delete;
method VideoBuffer (line 811) | VideoBuffer(VideoBuffer&& other) { *this = std::move(other); }
method VideoBuffer (line 813) | VideoBuffer& operator=(const VideoBuffer&) = delete;
method VideoBuffer (line 815) | VideoBuffer& operator=(VideoBuffer&& other) {
method resize (line 825) | Expected<void> resize(uint32_t width, uint32_t height, SurfaceLayo...
method VideoBufferInfo (line 860) | VideoBufferInfo video_frame_info() const { return buffer_info_; }
method MemoryStorageType (line 863) | MemoryStorageType storage_type() const { return memory_buffer_.sto...
method size (line 866) | uint64_t size() const { return memory_buffer_.size(); }
method byte (line 869) | byte* pointer() const { return memory_buffer_.pointer(); }
method getPlanarPrimitiveType (line 879) | static Expected<PrimitiveType> getPlanarPrimitiveType(VideoFormat ...
FILE: isaac_ros_gxf/gxf/core/include/gxf/network/tcp_client.hpp
type nvidia (line 22) | namespace nvidia {
type gxf (line 23) | namespace gxf {
class TcpClient (line 26) | class TcpClient : public TcpCodelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/network/tcp_client_socket.hpp
type nvidia (line 29) | namespace nvidia {
type gxf (line 30) | namespace gxf {
type TcpHeader (line 34) | struct TcpHeader {
type MessageHeader (line 42) | struct MessageHeader {
type TcpMessage (line 48) | struct TcpMessage {
class TcpClientSocket (line 62) | class TcpClientSocket : public Endpoint {
method TcpClientSocket (line 64) | TcpClientSocket() = default;
method TcpClientSocket (line 66) | TcpClientSocket(const TcpClientSocket& other) = delete;
method TcpClientSocket (line 67) | TcpClientSocket(TcpClientSocket&& other) { *this = std::move(other...
method TcpClientSocket (line 68) | TcpClientSocket& operator=(const TcpClientSocket& other) = delete;
method TcpClientSocket (line 69) | TcpClientSocket& operator=(TcpClientSocket&& other) {
method setMaximumAttempts (line 92) | void setMaximumAttempts(size_t attempts) { maximum_attempts_ = att...
method connected (line 96) | bool connected() const { return connected_; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/network/tcp_codelet.hpp
type nvidia (line 32) | namespace nvidia {
type gxf (line 33) | namespace gxf {
class TcpCodelet (line 36) | class TcpCodelet : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/network/tcp_server.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class TcpServer (line 30) | class TcpServer : public TcpCodelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/network/tcp_server_socket.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
class TcpServerSocket (line 31) | class TcpServerSocket {
method TcpServerSocket (line 33) | TcpServerSocket(const char* address, uint16_t port)
method TcpServerSocket (line 35) | TcpServerSocket() : address_{"0.0.0.0"}, port_{0}, socket_{-1} {}
method TcpServerSocket (line 37) | TcpServerSocket(const TcpServerSocket& other) = delete;
method TcpServerSocket (line 38) | TcpServerSocket(TcpServerSocket&& other) = default;
method TcpServerSocket (line 39) | TcpServerSocket& operator=(const TcpServerSocket& other) = delete;
method TcpServerSocket (line 40) | TcpServerSocket& operator=(TcpServerSocket&& other) = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/npp/nppi_mul_c.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class NppiMulC (line 32) | class NppiMulC : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/npp/nppi_set.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class NppiSet (line 32) | class NppiSet : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/rmm/rmm_allocator.hpp
type nvidia (line 38) | namespace nvidia {
type gxf (line 39) | namespace gxf {
class RMMAllocator (line 42) | class RMMAllocator : public CudaAllocator {
method RMMAllocator (line 44) | RMMAllocator() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/component_serializer.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class ComponentSerializer (line 32) | class ComponentSerializer : public Component {
method gxf_result_t (line 38) | virtual gxf_result_t is_supported_abi(gxf_tid_t tid) {
method isSupported (line 50) | bool isSupported(gxf_tid_t tid) { return is_supported_abi(tid) == ...
method clearSerializer (line 72) | Expected<void> clearSerializer(gxf_tid_t tid) { return setSerializ...
method clearDeserializer (line 74) | Expected<void> clearDeserializer(gxf_tid_t tid) { return setDeseri...
method getSerializer (line 78) | Expected<Serializer> getSerializer() const {
method getDeserializer (line 85) | Expected<Deserializer> getDeserializer() const {
method setSerializer (line 92) | Expected<void> setSerializer(Serializer serializer) {
method setDeserializer (line 99) | Expected<void> setDeserializer(Deserializer deserializer) {
method clearSerializer (line 106) | Expected<void> clearSerializer(Serializer serializer) {
method clearDeserializer (line 113) | Expected<void> clearDeserializer(Deserializer deserializer) {
type SerializerFunctions (line 121) | struct SerializerFunctions {
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/endpoint.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class Endpoint (line 27) | class Endpoint : public Component {
method gxf_result_t (line 32) | virtual gxf_result_t is_write_available_abi() { return GXF_SUCCESS; }
method gxf_result_t (line 34) | virtual gxf_result_t is_read_available_abi() { return GXF_SUCCESS; }
method gxf_result_t (line 40) | virtual gxf_result_t write_ptr_abi(const void* pointer, size_t siz...
method writeTrivialType (line 53) | Expected<size_t> writeTrivialType(const T* object) { return write(...
method readTrivialType (line 57) | Expected<size_t> readTrivialType(T* object) { return read(object, ...
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_recorder.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class EntityRecorder (line 32) | class EntityRecorder : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_replayer.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class EntityReplayer (line 33) | class EntityReplayer : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_serializer.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class EntitySerializer (line 27) | class EntitySerializer : public Component {
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/file.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class File (line 32) | class File : public Endpoint {
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/file_stream.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
type EntityIndex (line 30) | struct EntityIndex {
class FileStream (line 41) | class FileStream : public Endpoint {
method FileStream (line 48) | FileStream(std::string input_file, std::string output_file)
method FileStream (line 50) | FileStream() = default;
method FileStream (line 52) | FileStream(const FileStream& other) = delete;
method FileStream (line 53) | FileStream(FileStream&& other) { *this = std::move(other); }
method FileStream (line 54) | FileStream& operator=(const FileStream& other) = delete;
method FileStream (line 55) | FileStream& operator=(FileStream&& other) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/serialization_buffer.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class SerializationBuffer (line 30) | class SerializationBuffer : public Endpoint {
method gxf_result_t (line 34) | gxf_result_t deinitialize() override { return ToResultCode(buffer_...
method MemoryStorageType (line 54) | MemoryStorageType storage_type() const { return buffer_.storage_ty...
method byte (line 56) | const byte* data() const { return buffer_.pointer(); }
method capacity (line 58) | size_t capacity() const { return buffer_.size(); }
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/std_component_serializer.hpp
type nvidia (line 29) | namespace nvidia {
type gxf (line 30) | namespace gxf {
class StdComponentSerializer (line 34) | class StdComponentSerializer : public ComponentSerializer {
method gxf_result_t (line 38) | gxf_result_t deinitialize() override { return GXF_SUCCESS; }
method serializeInteger (line 55) | Expected<size_t> serializeInteger(T value, Endpoint* endpoint) {
method deserializeInteger (line 64) | Expected<T> deserializeInteger(Endpoint* endpoint) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/std_entity_id_serializer.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
class StdEntityIdSerializer (line 30) | class StdEntityIdSerializer : public EntitySerializer {
type EntityHeader (line 33) | struct EntityHeader {
method gxf_result_t (line 39) | gxf_result_t initialize() override { return GXF_SUCCESS; }
method gxf_result_t (line 40) | gxf_result_t deinitialize() override { return GXF_SUCCESS; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/std_entity_serializer.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class StdEntitySerializer (line 41) | class StdEntitySerializer : EntitySerializer {
type EntityHeader (line 45) | struct EntityHeader {
type ComponentHeader (line 57) | struct ComponentHeader {
method gxf_result_t (line 66) | gxf_result_t deinitialize() override { return GXF_SUCCESS; }
type ComponentEntry (line 74) | struct ComponentEntry
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/tests/serialization_tester.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
type test (line 30) | namespace test {
class SerializationTester (line 34) | class SerializationTester : public Codelet {
method gxf_result_t (line 37) | gxf_result_t initialize() override { return GXF_SUCCESS; }
method gxf_result_t (line 38) | gxf_result_t deinitialize() override { return GXF_SUCCESS; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/serialization/tid_hash.hpp
type nvidia (line 22) | namespace nvidia {
type gxf (line 23) | namespace gxf {
type TidHash (line 26) | struct TidHash {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/allocator.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
type MemoryStorageType (line 28) | enum struct MemoryStorageType {
type ParameterParser<MemoryStorageType> (line 37) | struct ParameterParser<MemoryStorageType> {
method Parse (line 38) | static Expected<MemoryStorageType> Parse(gxf_context_t context, gx...
type ParameterWrapper<MemoryStorageType> (line 60) | struct ParameterWrapper<MemoryStorageType> {
method Wrap (line 61) | static Expected<YAML::Node> Wrap(gxf_context_t context, const Memo...
type AllocatorStage (line 88) | enum struct AllocatorStage : uint8_t {
type Allocator (line 96) | struct Allocator : public Component {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/async_buffer_receiver.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class AsyncBufferReceiver (line 36) | class AsyncBufferReceiver : public Receiver {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/async_buffer_transmitter.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class AsyncBufferTransmitter (line 37) | class AsyncBufferTransmitter : public Transmitter {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/block_memory_pool.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class FixedPoolUint64 (line 31) | class FixedPoolUint64
class BlockMemoryPool (line 35) | class BlockMemoryPool : public Allocator {
method MemoryStorageType (line 49) | MemoryStorageType storage_type() const {
method num_blocks (line 54) | uint64_t num_blocks() const {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/clock.hpp
type nvidia (line 24) | namespace nvidia {
type gxf (line 25) | namespace gxf {
class Clock (line 30) | class Clock : public Component {
class RealtimeClock (line 48) | class RealtimeClock : public Clock {
class ManualClock (line 72) | class ManualClock : public Clock {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/codelet.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class Codelet (line 29) | class Codelet : public Component {
method gxf_result_t (line 37) | virtual gxf_result_t start() { return GXF_SUCCESS; }
method gxf_result_t (line 50) | virtual gxf_result_t stop() { return GXF_SUCCESS; }
method getExecutionTimestamp (line 54) | int64_t getExecutionTimestamp() const { return execution_timestamp...
method getExecutionTime (line 58) | double getExecutionTime() const { return execution_time_; }
method getDeltaTime (line 62) | double getDeltaTime() const { return delta_time_; }
method getExecutionCount (line 66) | int64_t getExecutionCount() const { return execution_count_; }
method isFirstTick (line 69) | bool isFirstTick() const { return getExecutionCount() == 1; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/complex.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/component_allocator.hpp
type nvidia (line 22) | namespace nvidia {
type gxf (line 23) | namespace gxf {
class ComponentAllocator (line 26) | class ComponentAllocator {
method ComponentAllocator (line 30) | ComponentAllocator(const ComponentAllocator&) = delete;
method ComponentAllocator (line 31) | ComponentAllocator(ComponentAllocator&&) = delete;
method ComponentAllocator (line 32) | ComponentAllocator& operator=(const ComponentAllocator&) = delete;
method ComponentAllocator (line 33) | ComponentAllocator& operator=(ComponentAllocator&&) = delete;
method ComponentAllocator (line 46) | ComponentAllocator() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/component_factory.hpp
type nvidia (line 22) | namespace nvidia {
type gxf (line 23) | namespace gxf {
class ComponentFactory (line 27) | class ComponentFactory {
method ComponentFactory (line 31) | ComponentFactory(const ComponentFactory&) = delete;
method ComponentFactory (line 32) | ComponentFactory(ComponentFactory&&) = delete;
method ComponentFactory (line 33) | ComponentFactory& operator=(const ComponentFactory&) = delete;
method ComponentFactory (line 34) | ComponentFactory& operator=(ComponentFactory&&) = delete;
method ComponentFactory (line 47) | ComponentFactory() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/controller.hpp
type nvidia (line 24) | namespace nvidia {
type gxf (line 25) | namespace gxf {
type gxf_controller_status_t (line 45) | struct gxf_controller_status_t {
method gxf_controller_status_t (line 48) | gxf_controller_status_t(entity_state_t b_status,
method gxf_controller_status_t (line 51) | gxf_controller_status_t() {
class Controller (line 59) | class Controller : public Component {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/cpu_thread.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
type SchedulingPolicy (line 29) | enum class SchedulingPolicy : int32_t {
type ParameterParser<SchedulingPolicy> (line 37) | struct ParameterParser<SchedulingPolicy> {
method Parse (line 38) | static Expected<SchedulingPolicy> Parse(gxf_context_t context, gxf...
type ParameterWrapper<SchedulingPolicy> (line 58) | struct ParameterWrapper<SchedulingPolicy> {
method Wrap (line 59) | static Expected<YAML::Node> Wrap(gxf_context_t context, const Sche...
class CPUThread (line 82) | class CPUThread : public Component {
method pinned (line 86) | bool pinned() const {
method pinCores (line 90) | std::vector<uint32_t> pinCores() const {
method schedPolicy (line 98) | Expected<SchedulingPolicy> schedPolicy() const {
method schedPriority (line 102) | Expected<uint32_t> schedPriority() const {
method schedRuntime (line 106) | Expected<uint64_t> schedRuntime() const {
method schedDeadline (line 110) | Expected<uint64_t> schedDeadline() const {
method schedPeriod (line 114) | Expected<uint64_t> schedPeriod() const {
method isRealtime (line 119) | bool isRealtime() const {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/cuda_green_context.hpp
type nvidia (line 31) | namespace nvidia {
type gxf (line 32) | namespace gxf {
class CudaGreenContext (line 38) | class CudaGreenContext : public Component {
method CudaGreenContext (line 40) | CudaGreenContext() = default;
method index (line 53) | uint32_t index() const { return pool_index_; }
method CudaGreenContextPool (line 55) | CudaGreenContextPool* cudaGreenContextPool() const {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/cuda_green_context_pool.hpp
type nvidia (line 72) | namespace nvidia {
type gxf (line 73) | namespace gxf {
type CudaDriverFunctionTable (line 75) | struct CudaDriverFunctionTable {
class CudaGreenContextPool (line 94) | class CudaGreenContextPool : public Component {
method CudaGreenContextPool (line 96) | CudaGreenContextPool() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/default_extension.hpp
type nvidia (line 33) | namespace nvidia {
type gxf (line 34) | namespace gxf {
type detail (line 36) | namespace detail {
type VoidBaseHelper (line 38) | struct VoidBaseHelper {}
type BaseTypenameAsString (line 41) | struct BaseTypenameAsString {
type BaseTypenameAsString<VoidBaseHelper> (line 46) | struct BaseTypenameAsString<VoidBaseHelper> {
class DefaultExtension (line 54) | class DefaultExtension : public Extension {
method gxf_tid_t (line 88) | gxf_tid_t tid () const { return tid_; }
method add (line 91) | Expected<void> add(gxf_tid_t tid, const char* description, const c...
type Entry (line 135) | struct Entry {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/dlpack_utils.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/double_buffer_receiver.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class DoubleBufferReceiver (line 34) | class DoubleBufferReceiver : public Receiver {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/double_buffer_transmitter.hpp
type nvidia (line 29) | namespace nvidia {
type gxf (line 30) | namespace gxf {
class DoubleBufferTransmitter (line 35) | class DoubleBufferTransmitter : public Transmitter {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/eos.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
class EndOfStream (line 29) | class EndOfStream {
method stream_id (line 33) | int64_t stream_id() { return stream_id_; }
method stream_id (line 35) | void stream_id(int64_t stream_id) { stream_id_ = stream_id; }
method EndOfStream (line 37) | EndOfStream() = default;
method EndOfStream (line 41) | EndOfStream(const EndOfStream&) = delete;
method EndOfStream (line 43) | EndOfStream(EndOfStream&& other) { *this = std::move(other); }
method EndOfStream (line 45) | EndOfStream& operator=(const EndOfStream&) = delete;
method EndOfStream (line 47) | EndOfStream& operator=(EndOfStream&& other) {
method createEoSMessage (line 53) | static Expected<Entity> createEoSMessage(gxf_context_t context, in...
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/event_based_scheduler.hpp
type nvidia (line 51) | namespace nvidia {
type gxf (line 52) | namespace gxf {
class EntityExecutor (line 55) | class EntityExecutor
class EventBasedScheduler (line 62) | class EventBasedScheduler : public Scheduler {
type EntityOwnership (line 78) | enum class EntityOwnership : uint8_t {
class ScheduleEntity (line 83) | class ScheduleEntity {
method ScheduleEntity (line 85) | ScheduleEntity(gxf_uid_t eid, const char * name) {
method updateCondition (line 99) | void updateCondition() {
method tryToAcquire (line 103) | Expected<void> tryToAcquire(void) {
method releaseOwnership (line 111) | Expected<void> releaseOwnership(void) {
type TimeStat (line 135) | struct TimeStat {
type TimeStat (line 141) | struct TimeStat
type TimeStat (line 142) | struct TimeStat
type State (line 265) | enum class State : uint8_t {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/extension.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class Extension (line 28) | class Extension : public ComponentFactory {
method Extension (line 32) | Extension(const Extension&) = delete;
method Extension (line 33) | Extension(Extension&&) = delete;
method Extension (line 34) | Extension& operator=(const Extension&) = delete;
method Extension (line 35) | Extension& operator=(Extension&&) = delete;
method Extension (line 81) | Extension() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/extension_factory_helper.hpp
function gxf_result_t (line 128) | gxf_result_t GxfExtensionFactory(void** result) { ...
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/event_list/event_list.hpp
type nvidia (line 34) | namespace nvidia {
type gxf (line 35) | namespace gxf {
class EventList (line 39) | class EventList {
method EventList (line 41) | EventList() = default;
method EventList (line 42) | EventList(const EventList<T>&) = delete;
method EventList (line 43) | EventList& operator=(const EventList<T>&) = delete;
method pushEvent (line 46) | void pushEvent(T item) {
method removeEvent (line 53) | void removeEvent(T item) {
method popEvent (line 68) | Expected<T> popEvent() {
method exportList (line 78) | std::list<T> exportList() const {
method empty (line 84) | bool empty() const {
method size (line 90) | size_t size() const {
method hasEvent (line 96) | bool hasEvent(T item) const {
method clear (line 105) | void clear() {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/event_list/unique_event_list.hpp
type nvidia (line 34) | namespace nvidia {
type gxf (line 35) | namespace gxf {
class UniqueEventList (line 39) | class UniqueEventList {
method UniqueEventList (line 41) | UniqueEventList() = default;
method UniqueEventList (line 42) | UniqueEventList(const UniqueEventList<T>&) = delete;
method UniqueEventList (line 43) | UniqueEventList& operator=(const UniqueEventList<T>&) = delete;
method pushEvent (line 46) | bool pushEvent(T item) {
method removeEvent (line 56) | void removeEvent(T item) {
method popEvent (line 65) | Expected<T> popEvent() {
method exportList (line 76) | std::list<T> exportList() const {
method empty (line 82) | bool empty() const {
method size (line 88) | size_t size() const {
method hasEvent (line 94) | bool hasEvent(T item) const {
method clear (line 100) | void clear() {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/queue_thread/queue_thread.hpp
type nvidia (line 39) | namespace nvidia {
type gxf (line 40) | namespace gxf {
type UserItemWithPromise (line 46) | struct UserItemWithPromise {
method UserItemWithPromise (line 52) | UserItemWithPromise(ItemType i) : user_item(std::move(i)) {}
method UserItemWithPromise (line 53) | UserItemWithPromise() : is_stop_signal(true) {}
class GuardQueue (line 60) | class GuardQueue {
method push (line 63) | void push(Entry data) {
method Entry (line 68) | Entry pop() {
method wakeupOnce (line 89) | void wakeupOnce() {
method clear (line 96) | void clear() {
method size (line 102) | int size() {
class QueueThread (line 131) | class QueueThread {
method QueueThread (line 139) | QueueThread(RunFunction run_function, const std::string& name)
method setThreadName (line 157) | void setThreadName(const std::string& name) {
method queueItem (line 186) | std::future<bool> queueItem(ItemType item) {
method size (line 197) | int size() {
method stop (line 204) | void stop() {
method wait (line 225) | void wait() {
method joinThread (line 248) | void joinThread() {
method threadLoop (line 270) | void threadLoop() {
method callerThreadId (line 328) | std::string callerThreadId() {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/staging_queue/staging_queue.hpp
type gxf (line 27) | namespace gxf {
type staging_queue (line 28) | namespace staging_queue {
type OverflowBehavior (line 32) | enum class OverflowBehavior {
class StagingQueue (line 72) | class StagingQueue {
method T (line 137) | const T& at(size_t index) const { return items_[index % items_.siz...
method T (line 138) | T& at(size_t index) { return items_[index % items_.size()]; }
function OverflowBehavior (line 191) | OverflowBehavior StagingQueue<T>::overflow_behavior() const {
function T (line 221) | const T& StagingQueue<T>::peek(size_t index) const {
function T (line 231) | const T& StagingQueue<T>::peek_backstage(size_t index) const {
function T (line 242) | const T& StagingQueue<T>::latest(size_t index) const {
function T (line 262) | T StagingQueue<T>::pop() {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/staging_queue/staging_queue_iterator.hpp
type gxf (line 22) | namespace gxf {
type staging_queue (line 23) | namespace staging_queue {
class StagingQueueIterator (line 49) | class StagingQueueIterator {
method StagingQueueIterator (line 57) | StagingQueueIterator() : data_(nullptr), size_(0), index_(0) {}
method StagingQueueIterator (line 62) | StagingQueueIterator(pointer data, size_t size, size_t index)
method StagingQueueIterator (line 65) | StagingQueueIterator(const StagingQueueIterator& other) = default;
method StagingQueueIterator (line 66) | StagingQueueIterator& operator=(const StagingQueueIterator& other)...
method StagingQueueIterator (line 67) | StagingQueueIterator(StagingQueueIterator&& other) = default;
method StagingQueueIterator (line 68) | StagingQueueIterator& operator=(StagingQueueIterator&& other) = de...
method StagingQueueIterator (line 72) | const StagingQueueIterator& operator++() {
method StagingQueueIterator (line 76) | StagingQueueIterator operator++(int) { return StagingQueueIterator...
method reference (line 78) | reference operator*() const { return data_[index_ % size_]; }
method pointer (line 79) | pointer operator->() const { return data_ + (index_ % size_); }
type std (line 101) | namespace std {
type iterator_traits<gxf::staging_queue::StagingQueueIterator<T>> (line 104) | struct iterator_traits<gxf::staging_queue::StagingQueueIterator<T>> {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/suballocators/first_fit_allocator.hpp
type nvidia (line 28) | namespace nvidia {
type gxf (line 29) | namespace gxf {
class FirstFitAllocator (line 36) | class FirstFitAllocator {
method FirstFitAllocator (line 44) | FirstFitAllocator() = default;
method allocate (line 52) | expected_t<int32_t> allocate(const int32_t size, const int chunk_s...
method acquire (line 78) | expected_t<std::pair<T*, int32_t>> acquire(const int32_t size) {
method release (line 92) | expected_t<void> release(const T* ptr) {
method getNumberOfChunks (line 102) | int32_t getNumberOfChunks(const int32_t size) const {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/suballocators/first_fit_allocator_base.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class FirstFitAllocatorBase (line 35) | class FirstFitAllocatorBase {
type Error (line 38) | enum class Error {
type Memory (line 76) | struct Memory {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/timed_job_list/timed_job_list.hpp
type nvidia (line 35) | namespace nvidia {
type gxf (line 36) | namespace gxf {
class TimedJobList (line 43) | class TimedJobList {
method TimedJobList (line 47) | TimedJobList(Clock_t clock) : clock_(clock), is_running_(false) {}
method sizeUnsafe (line 50) | size_t sizeUnsafe() const { return queue_.size(); }
method size (line 53) | size_t size() const {
method start (line 67) | void start() { is_running_.store(true); }
method stop (line 69) | void stop() {
method getNextTargetTime (line 79) | Expected<int64_t> getNextTargetTime() const {
method wakeOne (line 88) | void wakeOne() { queue_cv_.notify_one(); }
method wakeAll (line 90) | void wakeAll() { queue_cv_.notify_all(); }
method popFront (line 94) | Expected<JobT> popFront() {
method empty (line 114) | bool empty() const {
type Item (line 125) | struct Item {
type ItemPriorityCmp (line 137) | struct ItemPriorityCmp {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/utils/time.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
function getCurrentTimeUs (line 41) | inline uint64_t getCurrentTimeUs() {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/gems/video_buffer/allocator.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
type NoPaddingColorPlanes (line 29) | struct NoPaddingColorPlanes {}
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB> (line 31) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB> {
method NoPaddingColorPlanes (line 32) | explicit NoPaddingColorPlanes(uint32_t width) : planes({gxf::Color...
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR> (line 36) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR> {
method NoPaddingColorPlanes (line 37) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_RGBA> (line 42) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_RGBA> {
method NoPaddingColorPlanes (line 43) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_BGRA> (line 48) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_BGRA> {
method NoPaddingColorPlanes (line 49) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB16> (line 54) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB16> {
method NoPaddingColorPlanes (line 55) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR16> (line 60) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR16> {
method NoPaddingColorPlanes (line 61) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB32> (line 66) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_RGB32> {
method NoPaddingColorPlanes (line 67) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR32> (line 72) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_BGR32> {
method NoPaddingColorPlanes (line 73) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY> (line 78) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY> {
method NoPaddingColorPlanes (line 79) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY16> (line 84) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY1...
method NoPaddingColorPlanes (line 85) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY32> (line 90) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY3...
method NoPaddingColorPlanes (line 91) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY32F> (line 96) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_GRAY3...
method NoPaddingColorPlanes (line 97) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_NV12> (line 102) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_NV12> {
method NoPaddingColorPlanes (line 103) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_NV12_ER> (line 109) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_NV12_...
method NoPaddingColorPlanes (line 110) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_NV24> (line 116) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_NV24> {
method NoPaddingColorPlanes (line 117) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_NV24_ER> (line 123) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_NV24_...
method NoPaddingColorPlanes (line 124) | explicit NoPaddingColorPlanes(uint32_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_R8_G8_B8> (line 130) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_R8_G8...
method NoPaddingColorPlanes (line 131) | explicit NoPaddingColorPlanes(size_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_R16_G16_B16> (line 137) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_R16_G...
method NoPaddingColorPlanes (line 138) | explicit NoPaddingColorPlanes(size_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_R32_G32_B32> (line 144) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_R32_G...
method NoPaddingColorPlanes (line 145) | explicit NoPaddingColorPlanes(size_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_B8_G8_R8> (line 152) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_B8_G8...
method NoPaddingColorPlanes (line 153) | explicit NoPaddingColorPlanes(size_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_B16_G16_R16> (line 159) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_B16_G...
method NoPaddingColorPlanes (line 160) | explicit NoPaddingColorPlanes(size_t width)
type NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_B32_G32_R32> (line 167) | struct NoPaddingColorPlanes<gxf::VideoFormat::GXF_VIDEO_FORMAT_B32_G...
method NoPaddingColorPlanes (line 168) | explicit NoPaddingColorPlanes(size_t width)
function IsSupportedVideoFormat (line 175) | constexpr bool IsSupportedVideoFormat(const gxf::VideoFormat format) {
function AllocateUnpaddedVideoBuffer (line 200) | gxf::Expected<void> AllocateUnpaddedVideoBuffer(
function AllocateUnpaddedVideoBuffer (line 208) | gxf::Expected<void> AllocateUnpaddedVideoBuffer(
function AllocateVideoBuffer (line 227) | gxf::Expected<void> AllocateVideoBuffer(
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/graph_driver.hpp
type nvidia (line 34) | namespace nvidia {
type gxf (line 35) | namespace gxf {
class GraphDriver (line 52) | class GraphDriver : public System {
method GraphDriver (line 56) | GraphDriver() = default;
type Event (line 125) | struct Event {
type ParameterParser<GraphDriver::ConnectionMap> (line 138) | struct ParameterParser<GraphDriver::ConnectionMap> {
method Parse (line 139) | static Expected<GraphDriver::ConnectionMap> Parse(
type ParameterWrapper<GraphDriver::ConnectionMap> (line 161) | struct ParameterWrapper<GraphDriver::ConnectionMap> {
method Wrap (line 163) | static Expected<YAML::Node> Wrap(
type ParameterWrapper<std::vector<GraphDriver::ConnectionMap>> (line 179) | struct ParameterWrapper<std::vector<GraphDriver::ConnectionMap>> {
method Wrap (line 180) | static Expected<YAML::Node> Wrap(
type ParameterParser<std::vector<GraphDriver::ConnectionMap>> (line 196) | struct ParameterParser<std::vector<GraphDriver::ConnectionMap>> {
method Parse (line 197) | static Expected<std::vector<GraphDriver::ConnectionMap>> Parse(
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/graph_driver_worker_common.hpp
type nvidia (line 34) | namespace nvidia {
type gxf (line 35) | namespace gxf {
type ComponentParam (line 48) | struct ComponentParam {
type ParamInfo (line 49) | struct ParamInfo {
method serialize (line 67) | std::string serialize() const {
type ComponentInfo (line 72) | struct ComponentInfo {
method serialize (line 77) | std::string serialize() const {
method ComponentInfo (line 80) | static ComponentInfo deserialize(const std::string& data) {
type SegmentInfo (line 97) | struct SegmentInfo {
type WorkerInfo (line 104) | struct WorkerInfo {
method ip_port (line 108) | std::string ip_port() const {
class GraphDriverWorkerParser (line 113) | class GraphDriverWorkerParser {
method GraphDriverWorkerParser (line 115) | GraphDriverWorkerParser() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/graph_worker.hpp
type nvidia (line 32) | namespace nvidia {
type gxf (line 33) | namespace gxf {
type GraphSpec (line 38) | struct GraphSpec {
class SegmentRunner (line 48) | class SegmentRunner {
method SegmentRunner (line 52) | SegmentRunner(const std::string& name, const GraphSpec& graph_spec)
method SegmentRunner (line 58) | SegmentRunner(const std::string& name, const GraphSpec& graph_spec,
method SegmentRunner (line 64) | SegmentRunner(const std::string& name, const gxf_context_t context)
method SegmentRunner (line 70) | SegmentRunner(const std::string& name, const gxf_context_t context,
type Event (line 93) | struct Event {
class GraphWorker (line 134) | class GraphWorker : public System {
method GraphWorker (line 137) | GraphWorker() = default;
type Event (line 165) | struct Event {
type ParameterParser<GraphSpec> (line 212) | struct ParameterParser<GraphSpec> {
method Parse (line 213) | static Expected<GraphSpec> Parse(
type ParameterWrapper<GraphSpec> (line 239) | struct ParameterWrapper<GraphSpec> {
method Wrap (line 241) | static Expected<YAML::Node> Wrap(
type ParameterParser<std::map<std::string, GraphSpec>> (line 260) | struct ParameterParser<std::map<std::string, GraphSpec>> {
method Parse (line 261) | static Expected<std::map<std::string, GraphSpec>> Parse(
type ParameterWrapper<std::map<std::string, GraphSpec>> (line 282) | struct ParameterWrapper<std::map<std::string, GraphSpec>> {
method Wrap (line 284) | static Expected<YAML::Node> Wrap(
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/greedy_scheduler.hpp
type nvidia (line 39) | namespace nvidia {
type gxf (line 40) | namespace gxf {
class EntityExecutor (line 43) | class EntityExecutor
class GreedyScheduler (line 56) | class GreedyScheduler : public Scheduler {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/ipc_client.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
class IPCClient (line 31) | class IPCClient : public Component {
method toIpPort (line 59) | std::string toIpPort(const std::string& ip, uint32_t port) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/ipc_server.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class IPCServer (line 32) | class IPCServer : public Component {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/memory_buffer.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class MemoryBuffer (line 30) | class MemoryBuffer {
method MemoryBuffer (line 32) | MemoryBuffer() = default;
method MemoryBuffer (line 33) | MemoryBuffer(const MemoryBuffer&) = delete;
method MemoryBuffer (line 34) | MemoryBuffer& operator=(const MemoryBuffer&) = delete;
method MemoryBuffer (line 36) | MemoryBuffer(MemoryBuffer&& other) { *this = std::move(other); }
method MemoryBuffer (line 38) | MemoryBuffer& operator=(MemoryBuffer&& other) {
method freeBuffer (line 54) | Expected<void> freeBuffer() {
method resize (line 69) | Expected<void> resize(Handle<Allocator> allocator, uint64_t size,
method wrapMemory (line 99) | Expected<void> wrapMemory(void* pointer, uint64_t size,
method MemoryStorageType (line 116) | MemoryStorageType storage_type() const { return storage_type_; }
method byte (line 119) | byte* pointer() const { return pointer_; }
method size (line 122) | uint64_t size() const { return size_; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/metric.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class Metric (line 35) | class Metric : public Component {
method gxf_result_t (line 39) | gxf_result_t deinitialize() override { return GXF_SUCCESS; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/monitor.hpp
type nvidia (line 22) | namespace nvidia {
type gxf (line 23) | namespace gxf {
class Monitor (line 26) | class Monitor : public Component {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/multi_thread_scheduler.hpp
type nvidia (line 45) | namespace nvidia {
type gxf (line 46) | namespace gxf {
class EntityExecutor (line 49) | class EntityExecutor
class MultiThreadScheduler (line 59) | class MultiThreadScheduler : public Scheduler {
type State (line 172) | enum class State {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/network_context.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class NetworkContext (line 26) | class NetworkContext : public Component {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/new_component_allocator.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class NewComponentAllocator (line 28) | class NewComponentAllocator
method gxf_result_t (line 33) | gxf_result_t allocate_abi(void** out_pointer) override {
method gxf_result_t (line 44) | gxf_result_t deallocate_abi(void* pointer) override {
class NewComponentAllocator<T, std::enable_if_t<std::is_abstract<T>::value>> (line 55) | class NewComponentAllocator<T, std::enable_if_t<std::is_abstract<T>:...
method gxf_result_t (line 60) | gxf_result_t allocate_abi(void** out_pointer) override {
method gxf_result_t (line 64) | gxf_result_t deallocate_abi(void* pointer) override {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/queue.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class Queue (line 27) | class Queue : public Component {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/receiver.hpp
type nvidia (line 24) | namespace nvidia {
type gxf (line 25) | namespace gxf {
class Receiver (line 28) | class Receiver : public Queue {
method gxf_result_t (line 42) | virtual gxf_result_t sync_io_abi() { return GXF_SUCCESS; }
method gxf_result_t (line 44) | virtual gxf_result_t wait_abi() { return GXF_SUCCESS; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/resources.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
class ResourceBase (line 32) | class ResourceBase : public Component {}
class ThreadPool (line 34) | class ThreadPool : public ResourceBase {
type Thread (line 36) | struct Thread {
method coresToPin (line 50) | std::vector<uint32_t> coresToPin() const {
class GPUDevice (line 67) | class GPUDevice : public ResourceBase {
method device_id (line 70) | int32_t device_id() const { return dev_id_; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/scheduler.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class EntityExecutor (line 29) | class EntityExecutor
class Scheduler (line 34) | class Scheduler : public System {
type sched_attr (line 53) | struct sched_attr {
function sched_setattr (line 64) | static inline int
function sched_getattr (line 69) | static inline int
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_condition.hpp
type nvidia (line 21) | namespace nvidia {
type gxf (line 22) | namespace gxf {
type SchedulingConditionType (line 25) | enum class SchedulingConditionType : int32_t {
type SchedulingCondition (line 41) | struct SchedulingCondition {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_term.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
class SchedulingTerm (line 30) | class SchedulingTerm : public Component {
method gxf_result_t (line 43) | virtual gxf_result_t update_state_abi(int64_t timestamp) { return ...
method check (line 45) | Expected<SchedulingCondition> check(int64_t timestamp) {
method onExecute (line 54) | Expected<void> onExecute(int64_t timestamp) { return ExpectedOrCod...
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_term_combiner.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class SchedulingTermCombiner (line 35) | class SchedulingTermCombiner : public Component {
class OrSchedulingTermCombiner (line 48) | class OrSchedulingTermCombiner : public SchedulingTermCombiner {
method gxf_result_t (line 50) | gxf_result_t registerInterface(Registrar* registrar) override {
method SchedulingCondition (line 57) | SchedulingCondition combine(SchedulingCondition a, SchedulingCondi...
method getTermList (line 98) | FixedVector<Handle<SchedulingTerm>, kMaxComponents> getTermList() ...
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_terms.hpp
type nvidia (line 35) | namespace nvidia {
type gxf (line 36) | namespace gxf {
type PeriodicSchedulingPolicy (line 38) | enum class PeriodicSchedulingPolicy {
type ParameterParser<PeriodicSchedulingPolicy> (line 61) | struct ParameterParser<PeriodicSchedulingPolicy> {
method Parse (line 62) | static Expected<PeriodicSchedulingPolicy> Parse(gxf_context_t cont...
type ParameterWrapper<PeriodicSchedulingPolicy> (line 81) | struct ParameterWrapper<PeriodicSchedulingPolicy> {
method Wrap (line 82) | static Expected<YAML::Node> Wrap(gxf_context_t context, const Peri...
class PeriodicSchedulingTerm (line 106) | class PeriodicSchedulingTerm : public SchedulingTerm {
method recess_period_ns (line 115) | int64_t recess_period_ns() const { return recess_period_ns_; }
method last_run_timestamp (line 118) | Expected<int64_t> last_run_timestamp() const { return next_target_...
class CountSchedulingTerm (line 129) | class CountSchedulingTerm : public SchedulingTerm {
class DownstreamReceptiveSchedulingTerm (line 150) | class DownstreamReceptiveSchedulingTerm : public SchedulingTerm {
method transmitter (line 160) | Handle<Transmitter> transmitter() const { return transmitter_.get(...
method setReceivers (line 162) | void setReceivers(std::set<Handle<Receiver>> receivers) { receiver...
method setTransmitter (line 165) | Expected<void> setTransmitter(Handle<Transmitter> value) {
method setMinSize (line 169) | Expected<void> setMinSize(uint64_t value) {
class TargetTimeSchedulingTerm (line 184) | class TargetTimeSchedulingTerm : public SchedulingTerm {
class MessageAvailableSchedulingTerm (line 209) | class MessageAvailableSchedulingTerm : public SchedulingTerm {
method setReceiver (line 219) | Expected<void> setReceiver(Handle<Receiver> value) {
method setMinSize (line 223) | Expected<void> setMinSize(size_t value) {
method setFrontStageMaxSize (line 227) | Expected<void> setFrontStageMaxSize(size_t value) {
type SamplingMode (line 246) | enum struct SamplingMode {
type ParameterParser<SamplingMode> (line 253) | struct ParameterParser<SamplingMode> {
method Parse (line 254) | static Expected<SamplingMode> Parse(gxf_context_t context, gxf_uid...
type ParameterWrapper<SamplingMode> (line 270) | struct ParameterWrapper<SamplingMode> {
method Wrap (line 271) | static Expected<YAML::Node> Wrap(gxf_context_t context, const Samp...
class MultiMessageAvailableSchedulingTerm (line 292) | class MultiMessageAvailableSchedulingTerm : public SchedulingTerm {
method setMinSize (line 302) | Expected<void> setMinSize(size_t value) {
method setMinSum (line 306) | Expected<void> setMinSum(size_t value) {
method setSamplingMode (line 310) | Expected<void> setSamplingMode(SamplingMode value) {
method addReceiver (line 314) | Expected<void> addReceiver(Handle<Receiver> value) {
method addMinSize (line 321) | Expected<void> addMinSize(size_t value) {
class ExpiringMessageAvailableSchedulingTerm (line 341) | class ExpiringMessageAvailableSchedulingTerm : public SchedulingTerm {
class BooleanSchedulingTerm (line 358) | class BooleanSchedulingTerm : public SchedulingTerm {
class BTSchedulingTerm (line 380) | class BTSchedulingTerm : public SchedulingTerm {
type AsynchronousEventState (line 396) | enum class AsynchronousEventState {
class AsynchronousSchedulingTerm (line 406) | class AsynchronousSchedulingTerm : public SchedulingTerm {
class MessageAvailableFrequencyThrottler (line 423) | class MessageAvailableFrequencyThrottler : public SchedulingTerm {
class MemoryAvailableSchedulingTerm (line 450) | class MemoryAvailableSchedulingTerm : public SchedulingTerm {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/system.hpp
type nvidia (line 22) | namespace nvidia {
type gxf (line 23) | namespace gxf {
class System (line 26) | class System : public Component {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/tensor.hpp
type nvidia (line 37) | namespace nvidia {
type gxf (line 38) | namespace gxf {
type PrimitiveType (line 41) | enum class PrimitiveType : int32_t {
type PrimitiveTypeTraits (line 63) | struct PrimitiveTypeTraits
class Shape (line 86) | class Shape {
method Shape (line 92) | Shape() : rank_(0) {}
method Shape (line 95) | Shape(std::initializer_list<int32_t> dimensions)
method Shape (line 106) | Shape(const std::vector<int32_t>& dimensions)
method Shape (line 117) | Shape(const std::array<int32_t, Shape::kMaxRank>& dims, uint32_t r...
method Shape (line 123) | Shape(const std::array<int32_t, N>& dims) : rank_(N) {
method rank (line 131) | uint32_t rank() const { return rank_; }
method size (line 135) | uint64_t size() const {
method dimension (line 147) | int32_t dimension(uint32_t index) const {
method valid (line 170) | bool valid() const {
type DLManagedTensorContext (line 198) | struct DLManagedTensorContext {
class DLManagedMemoryBuffer (line 220) | class DLManagedMemoryBuffer {
class Tensor (line 231) | class Tensor {
method Tensor (line 235) | Tensor() = default;
method Tensor (line 244) | Tensor(const Tensor&) = delete;
method Tensor (line 246) | Tensor(Tensor&& other) {
method Tensor (line 256) | Tensor& operator=(const Tensor&) = delete;
method Tensor (line 258) | Tensor& operator=(Tensor&& other) {
method MemoryStorageType (line 271) | MemoryStorageType storage_type() const { return memory_buffer_.sto...
method Shape (line 274) | const Shape& shape() const { return shape_; }
method rank (line 277) | uint32_t rank() const { return shape_.rank(); }
method PrimitiveType (line 280) | PrimitiveType element_type() const { return element_type_; }
method bytes_per_element (line 283) | uint64_t bytes_per_element() const { return bytes_per_element_; }
method element_count (line 286) | uint64_t element_count() const { return element_count_; }
method size (line 289) | size_t size() const { return memory_buffer_.size(); }
method byte (line 292) | byte* pointer() const { return memory_buffer_.pointer(); }
method MemoryBuffer (line 295) | MemoryBuffer move_buffer() { return std::move(memory_buffer_); }
method data (line 300) | Expected<T*> data() {
method data (line 310) | Expected<const T*> data() const {
method reshape (line 320) | Expected<void> reshape(const Shape& shape, MemoryStorageType stora...
method bytes_size (line 373) | uint64_t bytes_size() {
method stride (line 378) | uint64_t stride(uint32_t index) const {
method toDLManagedTensorContext (line 395) | Expected<std::shared_ptr<DLManagedTensorContext>&> toDLManagedTens...
type TensorDescription (line 459) | struct TensorDescription {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/timestamp.hpp
type nvidia (line 27) | namespace nvidia {
type gxf (line 28) | namespace gxf {
type Timestamp (line 32) | struct Timestamp {
type TimeDomainID (line 40) | enum class TimeDomainID : uint8_t {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/topic.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class Topic (line 30) | class Topic : public Component {
method getTopicName (line 35) | std::string getTopicName() const {
method getTransmitters (line 40) | std::vector<Handle<Transmitter>> getTransmitters() const { return ...
method getReceivers (line 43) | std::vector<Handle<Receiver>> getReceivers() const { return receiv...
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/transmitter.hpp
type nvidia (line 22) | namespace nvidia {
type gxf (line 23) | namespace gxf {
class Transmitter (line 26) | class Transmitter : public Queue {
method gxf_result_t (line 38) | virtual gxf_result_t sync_io_abi() { return GXF_SUCCESS; }
method gxf_result_t (line 40) | virtual gxf_result_t pop_io_abi(gxf_uid_t* uid) { return GXF_NOT_I...
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/unbounded_allocator.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class UnboundedAllocator (line 31) | class UnboundedAllocator : public Allocator {
method UnboundedAllocator (line 33) | UnboundedAllocator() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/vault.hpp
type nvidia (line 29) | namespace nvidia {
type gxf (line 30) | namespace gxf {
class Vault (line 33) | class Vault : public Codelet {
FILE: isaac_ros_gxf/gxf/core/include/gxf/std/yaml_file_loader.hpp
type YAML (line 33) | namespace YAML { class Node; }
class Node (line 33) | class Node
type nvidia (line 35) | namespace nvidia {
type gxf (line 36) | namespace gxf {
class ParameterStorage (line 38) | class ParameterStorage
class YamlFileLoader (line 43) | class YamlFileLoader {
method setParameterStorage (line 46) | void setParameterStorage(std::shared_ptr<ParameterStorage> paramet...
method setFileRoot (line 50) | void setFileRoot(const std::string& root) { root_ = root; }
FILE: isaac_ros_gxf/gxf/core/include/gxf/stream/stream_nvsci.hpp
type nvidia (line 25) | namespace nvidia {
type gxf (line 26) | namespace gxf {
type SyncType (line 28) | enum class SyncType {
type Stream (line 37) | struct Stream : public Component {
method gxf_result_t (line 41) | virtual gxf_result_t allocate_sync_object(SyncType signalerList,
method gxf_result_t (line 47) | virtual gxf_result_t signalSemaphore() {
method gxf_result_t (line 52) | virtual gxf_result_t waitSemaphore() {
method gxf_result_t (line 57) | virtual gxf_result_t setCudaStream(SyncType syncType, cudaStream_t...
method gxf_result_t (line 63) | virtual gxf_result_t importSemaphore(SyncType syncType) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/stream/stream_nvscisync.hpp
type nvidia (line 26) | namespace nvidia {
type gxf (line 27) | namespace gxf {
class StreamSync (line 29) | class StreamSync: public Stream {
method StreamSync (line 31) | StreamSync() = default;
FILE: isaac_ros_gxf/gxf/core/include/gxf/stream/stream_sync_id.hpp
type nvidia (line 23) | namespace nvidia {
type gxf (line 24) | namespace gxf {
type StreamSyncId (line 29) | struct StreamSyncId {
FILE: isaac_ros_gxf/gxf/core/include/gxf/stream/tests/test_gxf_stream_sync_cuda_helper.hpp
type nvidia (line 49) | namespace nvidia {
type gxf (line 50) | namespace gxf {
type stream (line 51) | namespace stream {
type test (line 52) | namespace test {
class StreamBasedOpsNew (line 59) | class StreamBasedOpsNew : public Codelet {
method getStream (line 61) | static Expected<Handle<CudaStream>> getStream(Entity& message) {
method addStream (line 71) | static Expected<void> addStream(Entity& message, Handle<CudaSt...
method getStreamSync (line 80) | static Expected<Handle<StreamSync>> getStreamSync(Entity& mess...
method addStreamSync (line 90) | static Expected<void> addStreamSync(Entity& message, Handle<St...
method addTensor (line 99) | static Expected<Handle<Tensor>> addTensor(Entity& message, Han...
class StreamTensorGeneratorNew (line 118) | class StreamTensorGeneratorNew : public StreamBasedOpsNew {
method gxf_result_t (line 120) | gxf_result_t initialize() override {
method gxf_result_t (line 144) | gxf_result_t tick() override {
method gxf_result_t (line 184) | gxf_result_t registerInterface(Registrar* registrar) override {
method createTensors (line 204) | Expected<void> createTensors(Entity& dev_msg, Entity& host_msg...
class DotProductExeNew (line 249) | class DotProductExeNew {
method DotProductExeNew (line 256) | DotProductExeNew() = default;
method setEnv (line 258) | void setEnv(const Handle<Receiver>& rx, const Handle<Transmitt...
method executeNew (line 268) | Expected<void> executeNew(Entity in_msg, const char* out_tenso...
class CublasDotProductNew (line 307) | class CublasDotProductNew : public StreamBasedOpsNew {
class CublasDotProductExe (line 310) | class CublasDotProductExe : public DotProductExeNew {
method CublasDotProductExe (line 316) | CublasDotProductExe(CublasDotProductNew* codelet) : codelet_...
method dotproduct_i (line 320) | Expected<void> dotproduct_i(float* in0, float* in1, float* o...
method CublasDotProductNew (line 351) | CublasDotProductNew() : exec_(this) {}
method gxf_result_t (line 353) | gxf_result_t initialize() override {
method gxf_result_t (line 361) | gxf_result_t tick() override {
method gxf_result_t (line 373) | gxf_result_t registerInterface(Registrar* registrar) override {
class HostDotProductNew (line 390) | class HostDotProductNew : public Codelet {
class HostDotProductExeNew (line 393) | class HostDotProductExeNew : public DotProductExeNew {
method HostDotProductExeNew (line 395) | HostDotProductExeNew() = default;
method dotproduct_i (line 397) | Expected<void> dotproduct_i(float* in0, float* in1, float* o...
method gxf_result_t (line 410) | gxf_result_t initialize() override {
method gxf_result_t (line 416) | gxf_result_t tick() override {
method gxf_result_t (line 424) | gxf_result_t registerInterface(Registrar* registrar) override {
class MemCpy2HostNew (line 441) | class MemCpy2HostNew : public StreamBasedOpsNew {
method gxf_result_t (line 443) | gxf_result_t tick() override {
method gxf_result_t (line 484) | gxf_result_t registerInterface(Registrar* registrar) override {
class VerifyEqualNew (line 499) | class VerifyEqualNew : public Codelet {
method gxf_result_t (line 501) | gxf_result_t tick() override {
method gxf_result_t (line 536) | gxf_result_t registerInterface(Registrar* registrar) override {
method fequal (line 544) | bool fequal(float a, float b) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_common.hpp
type nvidia (line 30) | namespace nvidia {
type gxf (line 31) | namespace gxf {
type _ucx_am_data_desc (line 33) | struct _ucx_am_data_desc {
type test_req (line 48) | struct test_req {
type UcxTransmitterSendContext (line 64) | struct UcxTransmitterSendContext {
type sockaddr_storage (line 74) | struct sockaddr_storage
FILE: isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_component_serializer.hpp
type nvidia (line 29) | namespace nvidia {
type gxf (line 30) | namespace gxf {
class UcxComponentSerializer (line 35) | class UcxComponentSerializer : public ComponentSerializer {
method gxf_result_t (line 39) | gxf_result_t deinitialize() override { return GXF_SUCCESS; }
method serializeInteger (line 68) | Expected<size_t> serializeInteger(T value, Endpoint* endpoint) {
method deserializeInteger (line 77) | Expected<T> deserializeInteger(Endpoint* endpoint) {
FILE: isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_context.hpp
type nvidia (line 37) | namespace nvidia {
type gxf (line 38) | namespace gxf {
type ucx_server_ctx (line 40) | struct ucx_server_ctx {
type UcxReceiverContext (line 49) | struct UcxReceiverContext {
type UcxTransmitterContext (line 61) | struct UcxTransmitterContext {
type ConnManager (line 69) | struct ConnManager {
class UcxContext (line 77) | class UcxContext : public NetworkContext {
FILE: isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_entity_serializer.hpp
type nvidia (line 30) | namespace nvidia {
type gxf (line 31) | namespace gxf {
class UcxEntitySerializer (line 44) | class UcxEntitySerializer : public EntitySerializer {
type EntityHeader (line 48) | struct EntityHeader {
type ComponentHeader (line 57) | struct ComponentHeader {
method gxf_result_t (line 65) | gxf_result_t initialize() override { return GXF_SUCCESS; }
method gxf_result_t (line 66) | gxf_result_t deinitialize() override { return GXF_SUCCESS; }
type ComponentEntry (line 76) | struct ComponentEntry
FILE: isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_receiver.hpp
type nvidia (line 39) | namespace nvidia {
type gxf (line 40) | namespace gxf {
class UcxReceiver (line 44) | class UcxReceiver : public Receiver {
FILE: isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_serialization_buffer.hpp
type nvidia (line 29) | namespace nvidia {
type gxf (line 30) | namespace gxf {
class UcxSerializationBuffer (line 33) | class UcxSerializationBuffer : public Endpoint {
method gxf_result_t (line 37) | gxf_result_t deinitialize() override { return ToResultCode(buffer_...
method byte (line 51) | const byte* data() const { return buffer_.pointer(); }
method ucp_dt_iov_t (line 52) | const ucp_dt_iov_t* iov_buffer() const { return iov_buffers_.data(...
method iov_buffer_size (line 53) | const size_t iov_buffer_size() const { return iov_buffers_.size(); }
method ucs_memory_type_t (line 54) | const ucs_memory_type_t mem_type() const {return mem_type_; }
method capacity (line 56) | size_t capacity() const { return buffer_.size(); }
FILE: isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_transmitter.hpp
type nvidia (line 38) | namespace nvidia {
type gxf (line 39) | namespace gxf {
class UcxTransmitter (line 42) | class UcxTransmitter : public Transmitter {
FILE: isaac_ros_gxf_extensions/gxf_isaac_atlas/gxf/extensions/atlas/composite_schema_server.hpp
type nvidia (line 25) | namespace nvidia {
type isaac (line 26) | namespace isaac {
class CompositeSchemaServer (line 33) | class CompositeSchemaServer : public gxf::Component {
method full (line 45) | bool full() const { return (schemas_.size() == schemas_.capacity()...
FILE: isaac_ros_gxf_extensions/gxf_isaac_atlas/gxf/extensions/atlas/pose_tree_frame.hpp
type nvidia (line 30) | namespace nvidia {
type isaac (line 31) | namespace isaac {
class PoseTreeFrame (line 35) | class PoseTreeFrame : public gxf::Component {
method frame_uid (line 42) | PoseTree::frame_t frame_uid() const { return frame_uid_; }
method interactive_marker (line 48) | bool interactive_marker() const { return interactive_marker_; }
FILE: isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/camera_info_synchronizer.cpp
type nvidia (line 26) | namespace nvidia {
type isaac (line 27) | namespace isaac {
function gxf_result_t (line 35) | gxf_result_t
function gxf_result_t (line 69) | gxf_result_t CameraInfoSynchronization::start() {
function gxf_result_t (line 75) | gxf_result_t CameraInfoSynchronization::dropOldestMessagesIfQueueIsF...
function gxf_result_t (line 98) | gxf_result_t CameraInfoSynchronization::useLatestCameraInfo() {
function gxf_result_t (line 142) | gxf_result_t syncMessages(const std::vector<int64_t>& acq_times,
function gxf_result_t (line 164) | gxf_result_t CameraInfoSynchronization::tick() {
FILE: isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/camera_info_synchronizer.hpp
type nvidia (line 33) | namespace nvidia {
type isaac (line 34) | namespace isaac {
class CameraInfoSynchronization (line 41) | class CameraInfoSynchronization : public gxf::Codelet {
FILE: isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/stereo_camera_synchronizer.cpp
type nvidia (line 25) | namespace nvidia {
type isaac (line 26) | namespace isaac {
function gxf_result_t (line 28) | gxf_result_t StereoCameraSynchronizer::registerInterface(gxf::Regist...
function gxf_result_t (line 49) | gxf_result_t StereoCameraSynchronizer::start() {
function gxf_result_t (line 60) | gxf_result_t StereoCameraSynchronizer::tick() {
FILE: isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/stereo_camera_synchronizer.hpp
type nvidia (line 23) | namespace nvidia {
type isaac (line 24) | namespace isaac {
class StereoCameraSynchronizer (line 30) | class StereoCameraSynchronizer : public gxf::Codelet {
method gxf_result_t (line 34) | gxf_result_t stop() override { return GXF_SUCCESS; }
FILE: isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/algorithm/string_utils.hpp
type nvidia (line 26) | namespace nvidia {
type isaac (line 27) | namespace isaac {
function StartsWith (line 30) | inline bool StartsWith(const std::string& str, const std::string& pr...
function EndsWith (line 36) | inline bool EndsWith(const std::string& str, const std::string& suff...
function RandomAlphaNumeric (line 43) | std::string RandomAlphaNumeric(size_t length, URBG&& rng) {
function SplitString (line 56) | inline std::vector<std::string> SplitString(const std::string& str, ...
function ToLowerCase (line 67) | inline std::string ToLowerCase(std::string data) {
function TrimString (line 73) | inline std::string TrimString(std::string s) {
function TakeLast (line 80) | inline std::string TakeLast(const std::string& str, size_t count) {
FILE: isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/common/composite_schema_uid.hpp
type nvidia (line 21) | namespace nvidia {
type isaac (line 22) | namespace isaac {
type CompositeSchemaUid (line 25) | struct CompositeSchemaUid {
FILE: isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/common/pose_frame_uid.hpp
type nvidia (line 21) | namespace nvidia {
type isaac (line 22) | namespace isaac {
type PoseFrameUid (line 25) | struct PoseFrameUid {
FILE: isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/composite/composite_from_tensor.hpp
type nvidia (line 24) | namespace nvidia {
type isaac (line 25) | namespace isaac {
type from_tensor_details (line 27) | namespace from_tensor_details {
function CompositeFromTensor (line 53) | gxf::Expected<T> CompositeFromTensor(
function CompositeFromTensor (line 66) | gxf::Expected<T> CompositeFromTensor(
function CompositeFromTensor (line 79) | gxf::Expected<T> CompositeFromTensor(::nvidia::isaac::CpuTensor<type...
function CompositeFromTensor (line 85) | gxf::Expected<T> CompositeFromTensor(
function CompositeFromTensor (line 103) | gxf::Expected<T> CompositeFromTensor(::nvidia::isaac::CpuTensor<type...
FILE: isaac_ros_gxf_extensions/gxf_isaac_gems/gxf/gems/composite/composite_view.hpp
type nvidia (line 25) | namespace nvidia {
type isaac (line 26) | namespace isaac {
type CompositeContainerConstPointer (line 30) | struct CompositeContainerConstPointer
method CompositeContainerConstPointer (line 41) | CompositeContainerConstPointer() : pointer(nullptr) {}
method CompositeContainerConstPointer (line 42) | CompositeContainerConstPointer(const K* p) : pointer(p) {}
method size (line 50) | constexpr int32_t size() const { return N; }
method K (line 52) | K operator[](int32_t i) const { return pointer[i]; }
type CompositeContainerPointer (line 32) | struct CompositeContainerPointer
method CompositeContainerPointer (line 67) | CompositeContainerPointer() : pointer(nullptr) {}
method CompositeContainerPointer (line 68) | CompositeContainerPointer(K* p) : pointer(p) {}
method size (line 76) | constexpr int32_t size() const { return N; }
method K (line 78) | K operator[](int32_t i) const { return pointer[i]; }
method K (line 79) | K& operator[](int32_t i) { return pointer[i]; }
type CompositeContainerArray (line 34) | struct CompositeContainerArray
method size (line 126) | constex
Condensed preview — 770 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (5,627K chars).
[
{
"path": ".gitattributes",
"chars": 754,
"preview": "# Ignore Python files in linguist\n*.py linguist-detectable=false\n\n# Images\n*.gif filter=lfs diff=lfs merge=lfs -text\n*.j"
},
{
"path": ".gitignore",
"chars": 126,
"preview": "# Ignore all pycache files\n**/__pycache__/**\n# Ignore ROS build files\n**/build/**\n**/install/**\n**/cc_internals/**\n**/l"
},
{
"path": "LICENSE",
"chars": 14794,
"preview": "NVIDIA ISAAC ROS SOFTWARE LICENSE\n\nThis license is a legal agreement between you and NVIDIA Corporation (\"NVIDIA\") and g"
},
{
"path": "README.md",
"chars": 5971,
"preview": "# Isaac ROS NITROS\n\nNVIDIA Isaac Transport for ROS package for hardware-acceleration friendly movement of messages.\n\n<di"
},
{
"path": "SECURITY.md",
"chars": 1917,
"preview": "## Security\n\nNVIDIA is dedicated to the security and trust of our software products and services, including all source c"
},
{
"path": "isaac_ros_gxf/CMakeLists.txt",
"chars": 5296,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All"
},
{
"path": "isaac_ros_gxf/cmake/isaac_ros_gxf-extras.cmake",
"chars": 1105,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All"
},
{
"path": "isaac_ros_gxf/cmake/modules/FindGXF.cmake",
"chars": 4730,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All"
},
{
"path": "isaac_ros_gxf/gxf/AMENT_IGNORE",
"chars": 0,
"preview": ""
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/assert.hpp",
"chars": 9665,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/backtrace.hpp",
"chars": 1036,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/byte.hpp",
"chars": 1033,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/endian.hpp",
"chars": 4452,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/expected.hpp",
"chars": 47498,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/fixed_map.hpp",
"chars": 17909,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/fixed_string.hpp",
"chars": 8049,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/fixed_vector.hpp",
"chars": 14195,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/iterator.hpp",
"chars": 9181,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/logger.hpp",
"chars": 6326,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/memory_utils.hpp",
"chars": 6057,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/nvtx_helper.hpp",
"chars": 2893,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/singleton.hpp",
"chars": 1863,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/span.hpp",
"chars": 5840,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/strong_type.hpp",
"chars": 4582,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/type_name.hpp",
"chars": 3483,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/type_name_gnuc.hpp",
"chars": 1664,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/type_utils.hpp",
"chars": 13624,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/unique_index_map.hpp",
"chars": 7801,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/common/yaml_parser.hpp",
"chars": 3279,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/dlpack/dlpack.h",
"chars": 7473,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2017-2024 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/application.hpp",
"chars": 10824,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/arg.hpp",
"chars": 14712,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/arg_parse.hpp",
"chars": 2193,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/config_parser.hpp",
"chars": 2841,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/driver.hpp",
"chars": 1817,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/entity_group.hpp",
"chars": 2671,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/extension_manager.hpp",
"chars": 2521,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/graph_entity.hpp",
"chars": 28717,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/graph_utils.hpp",
"chars": 1491,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/proxy_component.hpp",
"chars": 1746,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/segment.hpp",
"chars": 25388,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/app/worker.hpp",
"chars": 2419,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/constant_behavior.hpp",
"chars": 1802,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/entity_count_failure_repeat_controller.hpp",
"chars": 2120,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/parallel_behavior.hpp",
"chars": 2217,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/repeat_behavior.hpp",
"chars": 2150,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/selector_behavior.hpp",
"chars": 2186,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/sequence_behavior.hpp",
"chars": 2259,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/switch_behavior.hpp",
"chars": 2520,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/behavior_tree/timer_behavior.hpp",
"chars": 2230,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/common_expected_macro.hpp",
"chars": 16869,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/component.hpp",
"chars": 6591,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/entity.hpp",
"chars": 18965,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/expected.hpp",
"chars": 3153,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/expected_macro.hpp",
"chars": 4551,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/filepath.hpp",
"chars": 1657,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/gxf.h",
"chars": 59678,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/gxf_ext.h",
"chars": 14542,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/handle.hpp",
"chars": 10447,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter.hpp",
"chars": 13180,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_parser.hpp",
"chars": 12466,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_parser_std.hpp",
"chars": 7538,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_registrar.hpp",
"chars": 19411,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_storage.hpp",
"chars": 8910,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/parameter_wrapper.hpp",
"chars": 5362,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/registrar.hpp",
"chars": 8739,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/resource.hpp",
"chars": 3150,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/resource_manager.hpp",
"chars": 3450,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/resource_registrar.hpp",
"chars": 2912,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/core/type_registry.hpp",
"chars": 1704,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_allocator.hpp",
"chars": 1537,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_buffer.hpp",
"chars": 7999,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_common.hpp",
"chars": 2832,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_event.hpp",
"chars": 2764,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_scheduling_terms.hpp",
"chars": 5494,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream.hpp",
"chars": 3585,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_id.hpp",
"chars": 1342,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_pool.hpp",
"chars": 2753,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/cuda_stream_sync.hpp",
"chars": 1528,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/stream_ordered_allocator.hpp",
"chars": 2816,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/tests/convolution.h",
"chars": 1224,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/tests/green_context_with_smid.h",
"chars": 2218,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All ri"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/cuda/tests/test_cuda_helper.hpp",
"chars": 36075,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/logger/gxf_logger.hpp",
"chars": 4489,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/logger/logger.hpp",
"chars": 10890,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/multimedia/audio.hpp",
"chars": 5299,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/multimedia/camera.hpp",
"chars": 4442,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/multimedia/video.hpp",
"chars": 45808,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_client.hpp",
"chars": 1230,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_client_socket.hpp",
"chars": 4919,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_codelet.hpp",
"chars": 3383,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_server.hpp",
"chars": 1360,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/network/tcp_server_socket.hpp",
"chars": 2308,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/npp/nppi_mul_c.hpp",
"chars": 1501,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/npp/nppi_set.hpp",
"chars": 1530,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/rmm/rmm_allocator.hpp",
"chars": 3227,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/component_serializer.hpp",
"chars": 5623,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/endpoint.hpp",
"chars": 2538,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_recorder.hpp",
"chars": 1959,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_replayer.hpp",
"chars": 2042,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/entity_serializer.hpp",
"chars": 1951,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/file.hpp",
"chars": 2973,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/file_stream.hpp",
"chars": 3473,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/serialization_buffer.hpp",
"chars": 3052,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/std_component_serializer.hpp",
"chars": 2895,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/std_entity_id_serializer.hpp",
"chars": 2026,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/std_entity_serializer.hpp",
"chars": 4696,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/tests/serialization_tester.hpp",
"chars": 1912,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/serialization/tid_hash.hpp",
"chars": 1165,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/allocator.hpp",
"chars": 3885,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/async_buffer_receiver.hpp",
"chars": 2478,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/async_buffer_transmitter.hpp",
"chars": 1954,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/block_memory_pool.hpp",
"chars": 2299,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/clock.hpp",
"chars": 2923,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/codelet.hpp",
"chars": 4375,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/complex.hpp",
"chars": 1083,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/component_allocator.hpp",
"chars": 1734,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/component_factory.hpp",
"chars": 1748,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/controller.hpp",
"chars": 2607,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/cpu_thread.hpp",
"chars": 5025,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/cuda_green_context.hpp",
"chars": 2206,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All ri"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/cuda_green_context_pool.hpp",
"chars": 6002,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All ri"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/default_extension.hpp",
"chars": 5764,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/dlpack_utils.hpp",
"chars": 2309,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/double_buffer_receiver.hpp",
"chars": 2149,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/double_buffer_transmitter.hpp",
"chars": 2164,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/eos.hpp",
"chars": 2036,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/event_based_scheduler.hpp",
"chars": 10714,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/extension.hpp",
"chars": 3739,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/extension_factory_helper.hpp",
"chars": 9246,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/event_list/event_list.hpp",
"chars": 3098,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/event_list/unique_event_list.hpp",
"chars": 3204,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/queue_thread/queue_thread.hpp",
"chars": 10446,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/staging_queue/staging_queue.hpp",
"chars": 13645,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/staging_queue/staging_queue_iterator.hpp",
"chars": 4657,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/suballocators/first_fit_allocator.hpp",
"chars": 5039,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/suballocators/first_fit_allocator_base.hpp",
"chars": 4981,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/timed_job_list/timed_job_list.hpp",
"chars": 9756,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/utils/time.hpp",
"chars": 1851,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/gems/video_buffer/allocator.hpp",
"chars": 10460,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/graph_driver.hpp",
"chars": 7549,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/graph_driver_worker_common.hpp",
"chars": 4082,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/graph_worker.hpp",
"chars": 10779,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/greedy_scheduler.hpp",
"chars": 4196,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/ipc_client.hpp",
"chars": 2243,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/ipc_server.hpp",
"chars": 2332,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/memory_buffer.hpp",
"chars": 4184,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/metric.hpp",
"chars": 3850,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/monitor.hpp",
"chars": 1471,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/multi_thread_scheduler.hpp",
"chars": 7127,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/network_context.hpp",
"chars": 1382,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/new_component_allocator.hpp",
"chars": 2180,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/queue.hpp",
"chars": 1765,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 202-2025 NVIDIA CORPORATION & AFFILIATES. Al"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/receiver.hpp",
"chars": 1935,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/resources.hpp",
"chars": 2488,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduler.hpp",
"chars": 2137,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_condition.hpp",
"chars": 2117,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_term.hpp",
"chars": 2372,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_term_combiner.hpp",
"chars": 3963,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/scheduling_terms.hpp",
"chars": 18917,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/system.hpp",
"chars": 1654,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/tensor.hpp",
"chars": 18046,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/timestamp.hpp",
"chars": 2128,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/topic.hpp",
"chars": 1721,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/transmitter.hpp",
"chars": 1706,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/unbounded_allocator.hpp",
"chars": 1759,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/vault.hpp",
"chars": 2688,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/std/yaml_file_loader.hpp",
"chars": 4347,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/stream/stream_nvsci.hpp",
"chars": 2476,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/stream/stream_nvscisync.hpp",
"chars": 2493,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/stream/stream_sync_id.hpp",
"chars": 1287,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/stream/tests/test_gxf_stream_sync_cuda_helper.hpp",
"chars": 22791,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_common.hpp",
"chars": 2975,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_component_serializer.hpp",
"chars": 3703,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_context.hpp",
"chars": 5157,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_entity_serializer.hpp",
"chars": 4762,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_receiver.hpp",
"chars": 3241,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_serialization_buffer.hpp",
"chars": 2906,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/gxf/ucx/ucx_transmitter.hpp",
"chars": 3800,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2023-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf/gxf/core/include/third_party/LICENSE.txt",
"chars": 450113,
"preview": "================================================================================\nThis project uses the following softwar"
},
{
"path": "isaac_ros_gxf/package.xml",
"chars": 1435,
"preview": "<?xml version=\"1.0\"?>\n\n<!--\nCopyright (c) 2022-2024, NVIDIA CORPORATION. All rights reserved.\n\nNVIDIA CORPORATION and i"
},
{
"path": "isaac_ros_gxf/src/isaac_ros_gxf.cpp",
"chars": 811,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_argus/CMakeLists.txt",
"chars": 2761,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_argus/package.xml",
"chars": 1489,
"preview": "<?xml version=\"1.0\"?>\n\n<!--\nSPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reser"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_atlas/CMakeLists.txt",
"chars": 2898,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_atlas/gxf/extensions/atlas/composite_schema_server.hpp",
"chars": 2241,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_atlas/gxf/extensions/atlas/pose_tree_frame.hpp",
"chars": 2889,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2021-2025 NVIDIA CORPORATION & AFFILIATES. A"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_atlas/package.xml",
"chars": 1596,
"preview": "<?xml version=\"1.0\"?>\n\n<!--\nSPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reser"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/CMakeLists.txt",
"chars": 2197,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All righ"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/camera_info_synchronizer.cpp",
"chars": 12251,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All ri"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/camera_info_synchronizer.hpp",
"chars": 2905,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All ri"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/camera_utils.cpp",
"chars": 1697,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All ri"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/stereo_camera_synchronizer.cpp",
"chars": 5023,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All ri"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/gxf/extensions/camera_utils/stereo_camera_synchronizer.hpp",
"chars": 1951,
"preview": "// SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n// Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All ri"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_camera_utils/package.xml",
"chars": 1655,
"preview": "<?xml version=\"1.0\"?>\n\n<!--\nSPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reser"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_cuda/CMakeLists.txt",
"chars": 2907,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_cuda/package.xml",
"chars": 1489,
"preview": "<?xml version=\"1.0\"?>\n\n<!--\nSPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reser"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_flatscan_localization/CMakeLists.txt",
"chars": 2913,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_flatscan_localization/package.xml",
"chars": 1514,
"preview": "<?xml version=\"1.0\"?>\n\n<!--\nSPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reser"
},
{
"path": "isaac_ros_gxf_extensions/gxf_isaac_gems/CMakeLists.txt",
"chars": 2429,
"preview": "# SPDX-FileCopyrightText: NVIDIA CORPORATION & AFFILIATES\n# Copyright (c) 2024-2025 NVIDIA CORPORATION & AFFILIATES. All"
}
]
// ... and 570 more files (download for full content)
About this extraction
This page contains the full source code of the NVIDIA-ISAAC-ROS/isaac_ros_nitros GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 770 files (5.1 MB), approximately 1.4M tokens, and a symbol index with 4971 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.