Struct Peer 

pub struct Peer { /* private fields */ }

Available on crate feature client only.

A connected platform: the version agreed with it, where its endpoints are, and the token to authenticate with.

A Peer is built by the registration handshake or, for a connection that was established before this process started, from stored state with Peer::builder.

use ocpi_kit::client::Peer;
use ocpi_kit::transport::CredentialsToken;
use ocpi_kit::types::{PartyRef, Url};
use ocpi_kit::{InterfaceRole, ModuleId, VersionNumber};

let peer = Peer::builder(VersionNumber::V2_3_0, CredentialsToken::new("token-c")?)
    .versions_url(Url::new("https://cpo.example.com/ocpi/versions")?)
    .endpoint(ModuleId::Locations, InterfaceRole::Sender,
              Url::new("https://cpo.example.com/ocpi/cpo/2.3.0/locations")?)
    .party(PartyRef::new("NL", "TNM")?)
    .build();

assert!(peer.implements(&ModuleId::Locations, InterfaceRole::Sender));
assert!(!peer.implements(&ModuleId::Cdrs, InterfaceRole::Sender));

Implementations

impl Peer

Convenience constructors hanging off a Peer.

pub fn module<'a>( &'a self, transport: &'a Transport, module: ModuleId, from: PartyRef, ) -> ModuleClient<'a>

A client for an arbitrary module.

pub fn locations<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> LocationsSender<'a>

The Locations Sender client: pull Locations from this peer.

pub fn locations_receiver<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> LocationsReceiver<'a>

The Locations Receiver client: push Locations to this peer.

pub fn tokens<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> TokensSender<'a>

The Tokens Sender client: pull Tokens from, and authorize against, this peer.

pub fn cdrs<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> CdrsClient<'a>

The CDRs client.

pub fn tokens_receiver<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> TokensReceiver<'a>

The Tokens Receiver client: push Tokens to this peer.

pub fn sessions<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> SessionsSender<'a>

The Sessions Sender client: pull Sessions from this peer.

pub fn sessions_receiver<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> SessionsReceiver<'a>

The Sessions Receiver client: push Sessions to this peer.

pub fn tariffs<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> TariffsSender<'a>

The Tariffs Sender client: pull Tariffs from this peer.

pub fn tariffs_receiver<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> TariffsReceiver<'a>

The Tariffs Receiver client: push Tariffs to this peer.

pub fn commands<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> CommandsClient<'a>

The Commands client.

pub fn charging_profiles<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> ChargingProfilesClient<'a>

The Charging Profiles client.

pub fn hub_client_info<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> HubClientInfoClient<'a>

The Hub Client Info client.

pub fn payments<'a>( &'a self, transport: &'a Transport, from: PartyRef, ) -> PaymentsClient<'a>

The Payments client.

impl Peer

pub fn builder(version: VersionNumber, token: CredentialsToken) -> PeerBuilder

Starts building a peer that was registered in a previous run of this process.

pub const fn version(&self) -> &VersionNumber

The OCPI version agreed with this peer.

pub const fn token(&self) -> &CredentialsToken

The credentials token to authenticate requests to this peer with.

pub const fn versions_url(&self) -> Option<&Url>

The peer’s /versions endpoint.

pub fn parties(&self) -> &[PartyRef]

The parties this peer speaks for, from the roles of its credentials.

pub const fn hub(&self) -> Option<&PartyRef>

The hub this peer routes through, if it declared one.

pub const fn quirks(&self) -> &Quirks

The interoperability profile for this peer.

pub fn set_quirks(&mut self, quirks: Quirks)

Replaces the interoperability profile.

pub fn set_token(&mut self, token: CredentialsToken)

Replaces the credentials token, as a credentials PUT does.

pub fn implements(&self, module: &ModuleId, role: InterfaceRole) -> bool

Whether the peer implements a module in a given role.

pub fn endpoint_url( &self, module: &ModuleId, role: InterfaceRole, ) -> Option<&Url>

The peer’s URL for a module and role.

Module identifiers are matched case-insensitively when Quirks::case_insensitive_module_ids is on, which matters for the Booking module.

pub fn sender(&self, module: &ModuleId) -> Option<SenderEndpoint>

The Sender-interface endpoint of a module.

pub fn receiver(&self, module: &ModuleId) -> Option<ReceiverEndpoint>

The Receiver-interface endpoint of a module.

pub fn credentials_url(&self) -> Option<&Url>

The credentials endpoint, ignoring the advertised role as the specification instructs.

pub fn endpoints( &self, ) -> impl Iterator<Item = (&ModuleId, InterfaceRole, &Url)>

Every endpoint the peer advertised.

pub fn update_endpoints(&mut self, details: &VersionDetails)

Replaces the endpoint map from freshly fetched version details.

A credentials PUT requires this: “The server must fetch the client’s endpoints again, even if the version has not changed.”

pub fn routing_for(&self, party: Option<&PartyRef>) -> RoutingScenario

The routing scenario for a direct request to party, or an open request when the destination is unknown.

pub fn default_party(&self) -> Option<&PartyRef>

The party to address a functional request to, when the caller did not name one.

A peer that speaks for exactly one party needs no explicit to.

Trait Implementations

impl Clone for Peer

fn clone(&self) -> Peer

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Peer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.