|
| virtual | ~ITransport ()=default |
| | ITransport::~ITransport is a virtual destructor.
|
| |
| virtual Endpoint | localEndpoint () const =0 |
| | The endpoint of the calling process on this transport.
|
| |
| virtual int32_t | participantCount () const =0 |
| | The number of participants reachable through this transport.
|
| |
| virtual bool | send (const Endpoint &to, int32_t tag, const BufferDescriptor &payload, std::string *message=nullptr)=0 |
| | Sends a typed payload to a peer, blocking until the payload buffer is reusable.
|
| |
| virtual bool | receive (const Endpoint &from, int32_t tag, const BufferDescriptor &into, std::string *message=nullptr)=0 |
| | Receives a typed payload from a peer, blocking until it arrives.
|
| |
| virtual std::unique_ptr< IExchangeRequest > | sendAsync (const Endpoint &to, int32_t tag, const BufferDescriptor &payload)=0 |
| | Nonblocking send; the payload buffer must remain valid until the request completes.
|
| |
| virtual std::unique_ptr< IExchangeRequest > | receiveAsync (const Endpoint &from, int32_t tag, const BufferDescriptor &into)=0 |
| | Nonblocking receive; the destination buffer must remain valid until the request completes.
|
| |
| virtual | ~IIdentity ()=default |
| | IIdentity::~IIdentity is a virtual destructor.
|
| |
| virtual const std::string & | id () const =0 |
| | Gets a unique identifier for the entity.
|
| |
| virtual | ~IDescription ()=default |
| | IDescription::~IDescription is a virtual destructor.
|
| |
| virtual const std::string & | caption () const =0 |
| | Gets caption for the entity.
|
| |
| virtual void | setCaption (const std::string &caption)=0 |
| | Sets caption for the entity.
|
| |
| virtual const std::string & | description () const =0 |
| | Gets additional descriptive information for the entity.
|
| |
| virtual void | setDescription (const std::string &description)=0 |
| | Gets additional descriptive information for the entity.
|
| |
| virtual | ~IPropertyChanged ()=default |
| | IPropertyChanged::~IPropertyChanged is a virtual destructor.
|
| |
| virtual | ~ISignal ()=default |
| | ISignal::~ISignal is a virtual destructor.
|
| |
| virtual void | connect (const std::shared_ptr< ISlot< Args... > > &slot)=0 |
| | connect is used to connect a slot to the signal.
|
| |
| virtual void | disconnect (const std::shared_ptr< ISlot< Args... > > &slot)=0 |
| | disconnect is used to disconnect a slot from the signal.
|
| |
| virtual void | blockSignals (bool block)=0 |
| | blockSignals is used to block signals from being emitted.
|
| |
ITransport is a transport-neutral, tagged message channel between processes.
Implementations are provided by SDKs: an MPI transport (built on communicators/inter-communicators), an in-process transport (for testing distributed compositions without a launcher), or socket-based transports for cloud execution. Payloads are always typed BufferDescriptor views, so the bytes on the wire have the same layout discipline as the bytes in memory.
Threading contract: send/receive and their asynchronous variants are safe to call from multiple threads; message ordering is guaranteed only between a fixed (sender, receiver, tag) triple.
Payload rules: a payload whose kind is DataKind::String is refused with a message (it has no wire layout); a DataKind::Opaque payload must carry itemSizeBytes. Collective operations (barrier, reductions) are deliberately not part of this interface until a composition in the ecosystem needs them from the standard rather than from its transport's native API.
Payloads of a size the receiver cannot know. receive() and receiveAsync() fill a pre-allocated buffer, so the receiver must know the payload's shape. When it cannot — text such as an error message or a checkpoint token, a list that grows — the sender first sends the extent as a one-element DataKind::Int64 payload and then the payload itself, as a rank-1 buffer, on the same tag. Ordering per (sender, receiver, tag) guarantees the receiver reads them in that order. Text travels as its UTF-8 bytes in a DataKind::UInt8 buffer, never as DataKind::String.
Lost peers. A transport that can detect the loss of a peer (a closed connection, a process that has exited) must complete every pending operation with that peer, with failed() reporting the loss, so that wait() and a request's destructor return. A transport that cannot detect loss (plain MPI, where a lost rank typically aborts the job) must say so in its documentation; callers then bound their waits with the asynchronous operations and IExchangeRequest::waitFor(). The blocking send() and receive() carry no timeout: a caller that needs one uses the asynchronous form.