Struct BipClientBuilder 

pub struct BipClientBuilder { /* private fields */ }

BIP-specific builder that constructs BipTransport from interface/port/broadcast fields.

Implementations

impl BipClientBuilder

pub async fn build(self) -> Result<BACnetClient<BipTransport>, Error>

Build and start the client, constructing a BipTransport from the config.

pub async fn build_any(self) -> Result<BACnetClient<AnyTransport>, Error>

Build and start a configured B/IP client with a transport-erased type.

Uses the same settings and validation as Self::build, and returns a BACnetClient over its default transport type, AnyTransport.

use bacnet_client::client::BACnetClient;
let mut client: BACnetClient = BACnetClient::bip_builder()
    .port(0)
    .apdu_retries(2)
    .build_any().await?;
client.stop().await?;

pub async fn build_into<T>(self) -> Result<BACnetClient<T>, Error>

where T: TransportPort + From<BipTransport> + 'static,

Build and start a configured B/IP client over any transport type a BipTransport converts into, such as an application’s own enum of transports (#2071). Self::build_any is this with AnyTransport.

impl BipClientBuilder

pub fn event_channel_capacity(self, capacity: usize) -> Self

Set the independent event notification broadcast channel capacity.

pub fn apdu_retries(self, retries: u8) -> Self

Set the number of APDU retries before a confirmed request times out.

pub fn min_request_interval_ms(self, ms: u64) -> Self

Set the least time, in milliseconds, from the latest confirmed request to a destination finishing to the next being sent (default 0: no pacing; at most an hour). See ClientConfig::min_request_interval_ms.

pub fn max_segments(self, max_segments: Option<u8>) -> Self

Set the maximum number of APDU segments this client accepts.

Values 0 and 1 fail at build time. Other finite non-rung values are conservatively rounded down in Confirmed-Request headers.

pub fn segmented_response_accepted(self, accepted: bool) -> Self

Set whether this client accepts segmented responses.

pub fn proposed_window_size(self, window_size: u8) -> Self

Set the proposed segmented-transfer window size.

pub fn confirmed_cov_notification_ack_policy<F>(self, policy: F) -> Self

where F: Fn(&ReceivedCOVNotification) -> ConfirmedCOVNotificationResponse + Send + Sync + 'static,

Set the response policy for decoded ConfirmedCOVNotifications.

impl BipClientBuilder

pub fn multicast(self, multicast: Option<BipMulticast>) -> Self

Make the client a B/IP-M node in multicast’s group (Annex J.8), or, with None (the default), not: its broadcasts, Who-Is among them, go to the group, and it takes broadcasts only from the group. Needs an explicit interface, and a nonzero port unless the group has its own. A multicast TTL of 1, the default, keeps the group’s traffic on the local network. See BipTransport::set_multicast; build() fails on what it refuses.

use bacnet_client::client::BACnetClient;
use bacnet_transport::bip::BipMulticast;
use std::net::Ipv4Addr;
let group = BipMulticast::new(Ipv4Addr::new(239, 255, 66, 1))?;
let mut client = BACnetClient::bip_builder()
    .interface(Ipv4Addr::new(192, 0, 2, 20))
    .multicast(Some(group))
    .build()
    .await?;
client.stop().await?;

pub fn mode(self, mode: BipMode) -> Self

Set the B/IP mode: a normal node (the default), a foreign device or a BBMD (#938). build() starts the client locally; a foreign device doesn’t wait for its BBMD to accept the registration. Poll BACnetClient::foreign_registration for how it went: registered, and the last attempt’s outcome, a refusal included. Invalid TTL or renewal settings fail build() before any I/O.

use bacnet_client::client::BACnetClient;
use bacnet_transport::bip::{BipMode, ForeignDeviceConfig};
use std::{net::Ipv4Addr, time::Duration};
let mut client = BACnetClient::bip_builder()
    .port(0)
    .mode(BipMode::Foreign(ForeignDeviceConfig {
        bbmd_ip: Ipv4Addr::new(192, 0, 2, 10), bbmd_port: 47808,
        ttl: 60, renewal_interval: Some(Duration::from_secs(20)),
    }))
    .build().await?;
// A successful local start alone does not establish registration.
let registration = client.foreign_registration()?;
let (registered, last_attempt) = (registration.registered, registration.last_outcome);
client.stop().await?;

pub fn interface(self, ip: Ipv4Addr) -> Self

Set the local interface IP.

pub fn port(self, port: u16) -> Self

Set the UDP port (0 for ephemeral).

pub fn broadcast_address(self, addr: Ipv4Addr) -> Self

Set the directed broadcast address.

pub fn share_port_by_address(self, enabled: bool) -> Self

Bind the interface address itself, so transports on other addresses of this host can share the port, each getting only its own unicast (#1538). Off by default, which binds 0.0.0.0. Needs an explicit interface and a nonzero port, or build fails. See BipTransport::set_share_port_by_address for what changes.

pub fn apdu_timeout_ms(self, ms: u64) -> Self

Set APDU timeout in milliseconds.

pub fn max_apdu_length(self, len: u16) -> Self

Set the maximum APDU length this client accepts.

pub fn cov_channel_capacity(self, capacity: usize) -> Self

Set the COV notification broadcast channel capacity.