Struct NodeHandle 

pub struct NodeHandle<'a> { /* private fields */ }

Backend-agnostic node — borrows the session to create typed entities.

Implementations

impl<'a> NodeHandle<'a>

pub fn set_qos_overrides(&mut self, overrides: &'static [QosOverride])

Phase 211.H — install the plan’s QoS-override table on this node. Called by the generated entry BEFORE the component constructs its entities, so create_publisher/create_subscription fold the matching overrides in. The table is &'static (codegen bakes it as a static), so there is no lifetime to thread and no runtime allocation. Plan = authority: an override for a topic the entity creates is applied transparently (the user’s create_publisher(topic) call is unchanged, matching rclcpp).

pub fn qos_overrides(&self) -> &'static [QosOverride]

The installed QoS-override table (empty unless the entry set one).

pub fn name(&self) -> &str

Get the node name.

pub fn logger(&self) -> &'static Logger

Phase 88.12 — return the nros_log::Logger keyed on the node name.

Loggers are interned in nros-log’s bounded global table (nros_log::MAX_LOGGERS slots). If the caller has pre-registered a 'static Logger whose name matches this node’s name (via nros_log::register_logger), this method returns that exact reference — so subsequent nros_*! calls share per-logger runtime threshold state with any other call site that resolves the same name. Otherwise the call returns nros_log::DEFAULT_LOGGER, keeping the API total.

// Pre-register if you want a dedicated threshold:
static MY_NODE_LOGGER: nros_log::Logger =
    nros_log::Logger::new("my_node");
nros_log::register_logger(&MY_NODE_LOGGER);

// Inside any node-creating code:
let logger = node.logger();
nros_log::nros_info!(logger, "started; domain = {}", node.domain_id());

pub fn domain_id(&self) -> u32

Get the domain ID.

pub fn set_domain_id(&mut self, domain_id: u32)

Set the domain ID.

pub fn session_mut(&mut self) -> &mut CffiSession

Get a mutable reference to the underlying session.

pub fn create_publisher<M>( &mut self, topic_name: &str, ) -> Result<EmbeddedPublisher<M>, NodeError>

where M: MessageForRmw,

Create a publisher for the given topic.

pub fn create_publisher_with_qos<M>( &mut self, topic_name: &str, qos: QosSettings, ) -> Result<EmbeddedPublisher<M>, NodeError>

where M: MessageForRmw,

Create a publisher with custom QoS settings.

pub fn create_publisher_raw( &mut self, topic_name: &str, type_name: &str, type_hash: &str, ) -> Result<EmbeddedRawPublisher, NodeError>

Create a typeless publisher for non-ROS wire formats (e.g. PX4 uORB raw POD bytes, custom binary protocols). The caller supplies the type_name and type_hash strings used by backends that need them for liveliness/discovery; backends that don’t (uORB) can pass any stable string.

pub fn create_publisher_raw_with_qos( &mut self, topic_name: &str, type_name: &str, type_hash: &str, qos: QosSettings, ) -> Result<EmbeddedRawPublisher, NodeError>

Typeless publisher with custom QoS.

pub fn publisher<'t>(&mut self, topic: &'t str) -> PublisherBuilder<'_, 'a, 't>

Phase 189.M1 — the customizable publisher builder (the clone tier; see docs/design/0022-entity-api-tiers.md). Pick a mode with .typed::<M>() or .generic(type, hash), set knobs (.qos), then .build(). The convenient create_publisher / create_publisher_raw are the fork tier — sugar over this with defaults.

pub fn create_subscription<M>( &mut self, topic_name: &str, ) -> Result<Subscription<M>, NodeError>

where M: MessageForRmw,

Create a subscription for the given topic.

pub fn create_subscription_sized<M, const RX_BUF: usize>( &mut self, topic_name: &str, ) -> Result<Subscription<M, RX_BUF>, NodeError>

where M: MessageForRmw,

Create a subscription with custom buffer size.

pub fn create_subscription_with_qos<M, const RX_BUF: usize>( &mut self, topic_name: &str, qos: QosSettings, ) -> Result<Subscription<M, RX_BUF>, NodeError>

where M: MessageForRmw,

Create a subscription with custom QoS and buffer size.

pub fn create_subscription_raw( &mut self, topic_name: &str, type_name: &str, type_hash: &str, ) -> Result<RawSubscription, NodeError>

Create a typeless subscription. Caller decodes raw bytes themselves.

pub fn create_subscription_raw_sized<const RX_BUF: usize>( &mut self, topic_name: &str, type_name: &str, type_hash: &str, ) -> Result<RawSubscription<RX_BUF>, NodeError>

Typeless subscription with custom buffer size.

pub fn create_service<Svc>( &mut self, service_name: &str, ) -> Result<EmbeddedServiceServer<Svc>, NodeError>

where Svc: RosService, <Svc as RosService>::Request: MessageForRmw, <Svc as RosService>::Reply: MessageForRmw,

Create a service server.

pub fn create_service_with_qos<Svc>( &mut self, service_name: &str, qos: QosSettings, ) -> Result<EmbeddedServiceServer<Svc>, NodeError>

where Svc: RosService, <Svc as RosService>::Request: MessageForRmw, <Svc as RosService>::Reply: MessageForRmw,

Phase 193.2b — service server with an explicit QoS profile (applied to both the request + reply endpoints; rclcpp’s create_service(name, qos)).

pub fn create_service_sized<Svc, const REQ_BUF: usize, const REPLY_BUF: usize>( &mut self, service_name: &str, qos: QosSettings, ) -> Result<EmbeddedServiceServer<Svc, REQ_BUF, REPLY_BUF>, NodeError>

where Svc: RosService, <Svc as RosService>::Request: MessageForRmw, <Svc as RosService>::Reply: MessageForRmw,

Create a service server with custom buffer sizes + QoS.

pub fn create_client<Svc>( &mut self, service_name: &str, ) -> Result<EmbeddedServiceClient<Svc>, NodeError>

where Svc: RosService, <Svc as RosService>::Request: MessageForRmw, <Svc as RosService>::Reply: MessageForRmw,

Create a service client.

pub fn create_client_with_qos<Svc>( &mut self, service_name: &str, qos: QosSettings, ) -> Result<EmbeddedServiceClient<Svc>, NodeError>

where Svc: RosService, <Svc as RosService>::Request: MessageForRmw, <Svc as RosService>::Reply: MessageForRmw,

Phase 193.2b — service client with an explicit QoS profile.

pub fn create_client_sized<Svc, const REQ_BUF: usize, const REPLY_BUF: usize>( &mut self, service_name: &str, qos: QosSettings, ) -> Result<EmbeddedServiceClient<Svc, REQ_BUF, REPLY_BUF>, NodeError>

where Svc: RosService, <Svc as RosService>::Request: MessageForRmw, <Svc as RosService>::Reply: MessageForRmw,

Create a service client with custom buffer sizes + QoS.

pub fn create_service_raw( &mut self, service_name: &str, type_name: &str, type_hash: &str, ) -> Result<RawServiceServer, NodeError>

Typeless service server. L1 counterpart of [create_service] for the C / C++ FFI shims and callers that own their own scheduler. Returns a crate::executor::handles::RawServiceServer which polls request bytes directly.

pub fn create_service_raw_sized<const REQ_BUF: usize, const RESP_BUF: usize>( &mut self, service_name: &str, type_name: &str, type_hash: &str, ) -> Result<RawServiceServer<REQ_BUF, RESP_BUF>, NodeError>

Typeless service server with custom buffer sizes.

pub fn create_client_raw( &mut self, service_name: &str, type_name: &str, type_hash: &str, ) -> Result<RawServiceClient, NodeError>

Typeless service client. L1 counterpart of [create_client].

pub fn create_client_raw_sized<const REQ_BUF: usize, const REPLY_BUF: usize>( &mut self, service_name: &str, type_name: &str, type_hash: &str, ) -> Result<RawServiceClient<REQ_BUF, REPLY_BUF>, NodeError>

Typeless service client with custom buffer sizes.

pub fn create_action_server_raw( &mut self, action_name: &str, type_name: &str, type_hash: &str, ) -> Result<ActionServerCore<nros_node::::executor::node::{impl#0}::create_action_server_raw::{constant#0}, nros_node::::executor::node::{impl#0}::create_action_server_raw::{constant#1}, nros_node::::executor::node::{impl#0}::create_action_server_raw::{constant#2}>, NodeError>

Phase 122.3.c.6 — typeless action server. Builds the 5 transport channels (send_goal / cancel_goal / get_result services + feedback / status publishers) and returns the raw ActionServerCore directly. Caller owns scheduling — drives try_recv_goal_request / publish_feedback_raw / complete_goal_raw / try_handle_cancel / try_handle_get_result_raw on the returned core.

pub fn create_action_server_raw_sized<const GOAL_BUF: usize, const RESULT_BUF: usize, const FEEDBACK_BUF: usize, const MAX_GOALS: usize>( &mut self, action_name: &str, type_name: &str, type_hash: &str, ) -> Result<ActionServerCore<GOAL_BUF, RESULT_BUF, FEEDBACK_BUF, MAX_GOALS>, NodeError>

Typeless action server with custom buffer + goal-slot sizes.

pub fn create_action_client_raw( &mut self, action_name: &str, type_name: &str, type_hash: &str, ) -> Result<ActionClientCore<nros_node::::executor::node::{impl#0}::create_action_client_raw::{constant#0}, nros_node::::executor::node::{impl#0}::create_action_client_raw::{constant#1}, nros_node::::executor::node::{impl#0}::create_action_client_raw::{constant#2}>, NodeError>

Phase 122.3.c.6 — typeless action client. Same shape as create_action_server_raw but builds the 3 service clients

• 1 feedback subscriber, returns the raw ActionClientCore.

pub fn create_action_client_raw_sized<const GOAL_BUF: usize, const RESULT_BUF: usize, const FEEDBACK_BUF: usize>( &mut self, action_name: &str, type_name: &str, type_hash: &str, ) -> Result<ActionClientCore<GOAL_BUF, RESULT_BUF, FEEDBACK_BUF>, NodeError>

Typeless action client with custom buffer sizes.

pub fn create_action_server<A>( &mut self, action_name: &str, ) -> Result<ActionServer<A>, NodeError>

where A: RosAction, <A as RosAction>::Goal: MessageForRmw, <A as RosAction>::Result: MessageForRmw, <A as RosAction>::Feedback: MessageForRmw, <A as RosAction>::SendGoalRequest: MessageForRmw, <A as RosAction>::SendGoalResponse: MessageForRmw, <A as RosAction>::GetResultRequest: MessageForRmw, <A as RosAction>::GetResultResponse: MessageForRmw, <A as RosAction>::FeedbackMessage: MessageForRmw,

Create an action server.

pub fn create_action_server_sized<A, const GOAL_BUF: usize, const RESULT_BUF: usize, const FEEDBACK_BUF: usize, const MAX_GOALS: usize>( &mut self, action_name: &str, ) -> Result<ActionServer<A, GOAL_BUF, RESULT_BUF, FEEDBACK_BUF, MAX_GOALS>, NodeError>

where A: RosAction, <A as RosAction>::Goal: MessageForRmw, <A as RosAction>::Result: MessageForRmw, <A as RosAction>::Feedback: MessageForRmw, <A as RosAction>::SendGoalRequest: MessageForRmw, <A as RosAction>::SendGoalResponse: MessageForRmw, <A as RosAction>::GetResultRequest: MessageForRmw, <A as RosAction>::GetResultResponse: MessageForRmw, <A as RosAction>::FeedbackMessage: MessageForRmw,

Create an action server with custom buffer sizes.

pub fn create_action_client<A>( &mut self, action_name: &str, ) -> Result<ActionClient<A>, NodeError>

where A: RosAction, <A as RosAction>::Goal: MessageForRmw, <A as RosAction>::Result: MessageForRmw, <A as RosAction>::Feedback: MessageForRmw, <A as RosAction>::SendGoalRequest: MessageForRmw, <A as RosAction>::SendGoalResponse: MessageForRmw, <A as RosAction>::GetResultRequest: MessageForRmw, <A as RosAction>::GetResultResponse: MessageForRmw, <A as RosAction>::FeedbackMessage: MessageForRmw,

Create an action client.

pub fn create_action_client_sized<A, const GOAL_BUF: usize, const RESULT_BUF: usize, const FEEDBACK_BUF: usize>( &mut self, action_name: &str, ) -> Result<ActionClient<A, GOAL_BUF, RESULT_BUF, FEEDBACK_BUF>, NodeError>

where A: RosAction, <A as RosAction>::Goal: MessageForRmw, <A as RosAction>::Result: MessageForRmw, <A as RosAction>::Feedback: MessageForRmw, <A as RosAction>::SendGoalRequest: MessageForRmw, <A as RosAction>::SendGoalResponse: MessageForRmw, <A as RosAction>::GetResultRequest: MessageForRmw, <A as RosAction>::GetResultResponse: MessageForRmw, <A as RosAction>::FeedbackMessage: MessageForRmw,

Create an action client with custom buffer sizes.