bookclerk_plugin_abi::plugin_capnp::destination

Development These docs follow the development version and change with every merge.

Last updated View as Markdown

Item Kind Summary
Server trait
Client struct
Owned struct
ServerDispatch struct
HeadParams type alias
HeadResults type alias
ListParams type alias
ListResults type alias
GetParams type alias
GetResults type alias
PutParams type alias
PutResults type alias
CopyParams type alias
CopyResults type alias
DeleteParams type alias
DeleteResults type alias
CommitParams type alias
CommitResults type alias
AbortStageParams type alias
AbortStageResults type alias
MoveParams type alias
MoveResults type alias
MoveManyParams type alias
MoveManyResults type alias
DeleteManyParams type alias
DeleteManyResults type alias
HeadManyParams type alias
HeadManyResults type alias
ChangesParams type alias
ChangesResults type alias
TranslateKeysParams type alias
TranslateKeysResults type alias

Modules

Traits

Server

pub trait Server: 'static {
    fn head(
        self: Rc<Self>,
        _: HeadParams,
        _: HeadResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn list(
        self: Rc<Self>,
        _: ListParams,
        _: ListResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn get(
        self: Rc<Self>,
        _: GetParams,
        _: GetResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn put(
        self: Rc<Self>,
        _: PutParams,
        _: PutResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn copy(
        self: Rc<Self>,
        _: CopyParams,
        _: CopyResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn delete(
        self: Rc<Self>,
        _: DeleteParams,
        _: DeleteResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn commit(
        self: Rc<Self>,
        _: CommitParams,
        _: CommitResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn abort_stage(
        self: Rc<Self>,
        _: AbortStageParams,
        _: AbortStageResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn move_(
        self: Rc<Self>,
        _: MoveParams,
        _: MoveResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn move_many(
        self: Rc<Self>,
        _: MoveManyParams,
        _: MoveManyResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn delete_many(
        self: Rc<Self>,
        _: DeleteManyParams,
        _: DeleteManyResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn head_many(
        self: Rc<Self>,
        _: HeadManyParams,
        _: HeadManyResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn changes(
        self: Rc<Self>,
        _: ChangesParams,
        _: ChangesResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
    fn translate_keys(
        self: Rc<Self>,
        _: TranslateKeysParams,
        _: TranslateKeysResults,
    ) -> impl Future<Output = Result<(), Error>> + 'static;
}

Server::head

fn head(
    self: Rc<Self>,
    _: HeadParams,
    _: HeadResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::list

fn list(
    self: Rc<Self>,
    _: ListParams,
    _: ListResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::get

fn get(
    self: Rc<Self>,
    _: GetParams,
    _: GetResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::put

fn put(
    self: Rc<Self>,
    _: PutParams,
    _: PutResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::copy

fn copy(
    self: Rc<Self>,
    _: CopyParams,
    _: CopyResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::delete

fn delete(
    self: Rc<Self>,
    _: DeleteParams,
    _: DeleteResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::commit

fn commit(
    self: Rc<Self>,
    _: CommitParams,
    _: CommitResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::abort_stage

fn abort_stage(
    self: Rc<Self>,
    _: AbortStageParams,
    _: AbortStageResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::move_

fn move_(
    self: Rc<Self>,
    _: MoveParams,
    _: MoveResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::move_many

fn move_many(
    self: Rc<Self>,
    _: MoveManyParams,
    _: MoveManyResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::delete_many

fn delete_many(
    self: Rc<Self>,
    _: DeleteManyParams,
    _: DeleteManyResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::head_many

fn head_many(
    self: Rc<Self>,
    _: HeadManyParams,
    _: HeadManyResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::changes

fn changes(
    self: Rc<Self>,
    _: ChangesParams,
    _: ChangesResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Server::translate_keys

fn translate_keys(
    self: Rc<Self>,
    _: TranslateKeysParams,
    _: TranslateKeysResults,
) -> impl Future<Output = Result<(), Error>> + 'static

Implemented by: DestinationServer

Structs

Client

pub struct Client {
    pub client: Client,
}

Client::head_request

pub fn head_request(&self) -> Request<Owned, Owned>

Client::list_request

pub fn list_request(&self) -> Request<Owned, Owned>

Client::get_request

pub fn get_request(&self) -> Request<Owned, Owned>

Client::put_request

pub fn put_request(&self) -> Request<Owned, Owned>

Client::copy_request

pub fn copy_request(&self) -> Request<Owned, Owned>

Client::delete_request

pub fn delete_request(&self) -> Request<Owned, Owned>

Client::commit_request

pub fn commit_request(&self) -> Request<Owned, Owned>

Client::abort_stage_request

pub fn abort_stage_request(&self) -> Request<Owned, Owned>

Client::move_request

pub fn move_request(&self) -> Request<Owned, Owned>

Client::move_many_request

pub fn move_many_request(&self) -> Request<Owned, Owned>

Client::delete_many_request

pub fn delete_many_request(&self) -> Request<Owned, Owned>

Client::head_many_request

pub fn head_many_request(&self) -> Request<Owned, Owned>

Client::changes_request

pub fn changes_request(&self) -> Request<Owned, Owned>

Client::translate_keys_request

pub fn translate_keys_request(&self) -> Request<Owned, Owned>

Implements: Clone, FromClientHook, FromPointerBuilder<'a>, FromPointerReader<'a>, FromServer<_S>, HasTypeId, SetterInput<Owned>

Owned

pub struct Owned(/* private */);

Implements: Clone, Copy, Introspect, Owned, Pipelined, SetterInput<Owned>

ServerDispatch

pub struct ServerDispatch<_T> {
    pub server: Rc<_T>,
}

ServerDispatch::dispatch_call_internal

pub fn dispatch_call_internal(
    this: Rc<_T>,
    method_id: u16,
    params: Params<Owned>,
    results: Results<Owned>,
) -> DispatchCallResult

Implements: Clone, Deref, Server

Type aliases

HeadParams

pub type HeadParams = Params<Owned>;

HeadResults

pub type HeadResults = Results<Owned>;

ListParams

pub type ListParams = Params<Owned>;

ListResults

pub type ListResults = Results<Owned>;

GetParams

pub type GetParams = Params<Owned>;

GetResults

pub type GetResults = Results<Owned>;

PutParams

pub type PutParams = Params<Owned>;

PutResults

pub type PutResults = Results<Owned>;

CopyParams

pub type CopyParams = Params<Owned>;

CopyResults

pub type CopyResults = Results<Owned>;

DeleteParams

pub type DeleteParams = Params<Owned>;

DeleteResults

pub type DeleteResults = Results<Owned>;

CommitParams

pub type CommitParams = Params<Owned>;

CommitResults

pub type CommitResults = Results<Owned>;

AbortStageParams

pub type AbortStageParams = Params<Owned>;

AbortStageResults

pub type AbortStageResults = Results<Owned>;

MoveParams

pub type MoveParams = Params<Owned>;

MoveResults

pub type MoveResults = Results<Owned>;

MoveManyParams

pub type MoveManyParams = Params<Owned>;

MoveManyResults

pub type MoveManyResults = Results<Owned>;

DeleteManyParams

pub type DeleteManyParams = Params<Owned>;

DeleteManyResults

pub type DeleteManyResults = Results<Owned>;

HeadManyParams

pub type HeadManyParams = Params<Owned>;

HeadManyResults

pub type HeadManyResults = Results<Owned>;

ChangesParams

pub type ChangesParams = Params<Owned>;

ChangesResults

pub type ChangesResults = Results<Owned>;

TranslateKeysParams

pub type TranslateKeysParams = Params<Owned>;

TranslateKeysResults

pub type TranslateKeysResults = Results<Owned>;

Generated from crates/bookclerk-plugin-abi at main · View as Markdown