Skip to main content

CocoonServiceImpl

Mountain::RPC::CocoonService

Struct CocoonServiceImpl 

Source 
pub struct CocoonServiceImpl {
    environment: Arc<MountainEnvironment>,
    ActiveOperations: Arc<RwLock<HashMap<u64, CancellationToken>>>,
}
Expand description

Implementation of the CocoonService gRPC server

This struct handles all incoming requests from the Cocoon extension host sidecar and dispatches them to the appropriate Mountain services.

Fields§

§environment: Arc<MountainEnvironment>

Mountain environment providing access to all services

§ActiveOperations: Arc<RwLock<HashMap<u64, CancellationToken>>>

Registry of active operations with their cancellation tokens Maps request ID to cancellation token for operation cancellation

Implementations§

Source§

impl CocoonServiceImpl

Source

pub fn new(environment: Arc<MountainEnvironment>) -> Self

Creates a new instance of the CocoonService server

§Parameters
  • environment: Mountain environment with access to all services
§Returns

A new CocoonService instance

Source

pub async fn RegisterOperation(&self, request_id: u64) -> CancellationToken

Registers an operation for potential cancellation

§Parameters
  • request_id: The request identifier for the operation
§Returns

A cancellation token that can be used to cancel the operation

Source

pub async fn UnregisterOperation(&self, request_id: u64)

Unregisters an operation after completion

§Parameters
  • request_id: The request identifier to unregister
Source

fn RegisterProvider( &self, handle: u32, provider_type: ProviderType, language_selector: &str, extension_id: &str, )

Registers a language feature provider in ApplicationState.

Converts the gRPC request fields into a ProviderRegistrationDTO and stores it in ApplicationState.Extension.ProviderRegistration.

§Parameters
  • handle: Unique provider handle
  • provider_type: The type of language feature
  • language_selector: Language scope (e.g. “typescript”)
  • extension_id: Extension that registered this provider
Source

fn UriToPath(uri_opt: Option<&Uri>) -> Option<PathBuf>

Extracts a filesystem path from a URI proto message.

Handles both file:// URIs and bare paths. Returns None if the URI is absent or the path cannot be extracted.

Trait Implementations§

Source§

impl Clone for CocoonServiceImpl

Source§

fn clone(&self) -> CocoonServiceImpl

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl CocoonService for CocoonServiceImpl

Source§

fn process_mountain_request<'life0, 'async_trait>( &'life0 self, request: Request<GenericRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GenericResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Process Mountain requests from Cocoon (generic request-response).

Routes legacy fs.* / commands.* / secrets.* method names used by Cocoon’s FileSystemService and other services that call Mountain via the generic ProcessCocoonRequest RPC instead of the typed methods.

Parameters are JSON-encoded bytes in request.parameter. Results are JSON-encoded bytes in response.result.

Source§

fn send_mountain_notification<'life0, 'async_trait>( &'life0 self, request: Request<GenericNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Send Mountain notifications to Cocoon (generic fire-and-forget) Routes by notification.method string to the appropriate Mountain handler. Called by Cocoon’s MountainGRPCClient.sendNotification(method, params).

Source§

fn cancel_operation<'life0, 'async_trait>( &'life0 self, request: Request<CancelOperationRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Cancel operations requested by Mountain

Source§

type OpenChannelFromMountainStream = Pin<Box<dyn Stream<Item = Result<Envelope, Status>> + Send>>

Server streaming response type for the OpenChannelFromMountain method.
Source§

fn open_channel_from_mountain<'life0, 'async_trait>( &'life0 self, _request: Request<Streaming<Envelope>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::OpenChannelFromMountainStream>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

LAND-PATCH B7-S6 P2: bidirectional streaming channel (mirror of MountainService::OpenChannelFromCocoon). Mountain opens this stream once per Cocoon connection; all subsequent traffic multiplexes over it. Reverses the call direction so Mountain is the streaming initiator (which matches the typical “client opens stream, server replies” gRPC idiom).
Source§

fn initial_handshake<'life0, 'async_trait>( &'life0 self, request: Request<Empty>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Handshake - Called by Cocoon to signal readiness
Source§

fn init_extension_host<'life0, 'async_trait>( &'life0 self, request: Request<InitExtensionHostRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Initialize Extension Host - Mountain sends initialization data to Cocoon
Source§

fn register_command<'life0, 'async_trait>( &'life0 self, request: Request<RegisterCommandRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Command - Cocoon registers an extension command
Source§

fn execute_contributed_command<'life0, 'async_trait>( &'life0 self, request: Request<ExecuteCommandRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ExecuteCommandResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Execute Contributed Command - Mountain executes an extension command
Source§

fn unregister_command<'life0, 'async_trait>( &'life0 self, request: Request<UnregisterCommandRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Unregister Command - Unregister a previously registered command
Source§

fn register_hover_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Hover Provider - Register a hover provider
Source§

fn provide_hover<'life0, 'async_trait>( &'life0 self, request: Request<ProvideHoverRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideHoverResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Hover - Request hover information
Source§

fn register_completion_item_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Completion Item Provider - Register a completion provider
Source§

fn provide_completion_items<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCompletionItemsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCompletionItemsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Completion Items - Request completion items
Source§

fn register_definition_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Definition Provider - Register a definition provider
Source§

fn provide_definition<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDefinitionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDefinitionResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Definition - Request definition location
Source§

fn register_reference_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Reference Provider - Register a reference provider
Source§

fn provide_references<'life0, 'async_trait>( &'life0 self, request: Request<ProvideReferencesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideReferencesResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide References - Request references
Source§

fn register_code_actions_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Code Actions Provider - Register code actions provider
Source§

fn provide_code_actions<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCodeActionsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCodeActionsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Code Actions - Request code actions
Source§

fn show_text_document<'life0, 'async_trait>( &'life0 self, request: Request<ShowTextDocumentRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowTextDocumentResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Show Text Document - Open a text document
Source§

fn show_information_message<'life0, 'async_trait>( &'life0 self, request: Request<ShowMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Show Information Message - Display an info message
Source§

fn show_warning_message<'life0, 'async_trait>( &'life0 self, request: Request<ShowMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Show Warning Message - Display a warning message
Source§

fn show_error_message<'life0, 'async_trait>( &'life0 self, request: Request<ShowMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Show Error Message - Display an error message
Source§

fn create_status_bar_item<'life0, 'async_trait>( &'life0 self, request: Request<CreateStatusBarItemRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateStatusBarItemResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Create Status Bar Item - Create a status bar item
Source§

fn set_status_bar_text<'life0, 'async_trait>( &'life0 self, request: Request<SetStatusBarTextRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Set Status Bar Text - Set status bar text
Source§

fn create_webview_panel<'life0, 'async_trait>( &'life0 self, request: Request<CreateWebviewPanelRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateWebviewPanelResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Create Webview Panel - Create a new webview panel
Source§

fn set_webview_html<'life0, 'async_trait>( &'life0 self, request: Request<SetWebviewHtmlRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Set Webview HTML - Update webview HTML content
Source§

fn on_did_receive_message<'life0, 'async_trait>( &'life0 self, request: Request<OnDidReceiveMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

On Did Receive Message - Receive message from webview
Source§

fn post_webview_message<'life0, 'async_trait>( &'life0 self, request: Request<PostWebviewMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Post Message to Webview
Source§

fn dispose_webview_panel<'life0, 'async_trait>( &'life0 self, request: Request<DisposeWebviewPanelRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Dispose Webview Panel
Source§

fn read_file<'life0, 'async_trait>( &'life0 self, request: Request<ReadFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ReadFileResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Read File - Read file contents
Source§

fn write_file<'life0, 'async_trait>( &'life0 self, request: Request<WriteFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Write File - Write file contents
Source§

fn stat<'life0, 'async_trait>( &'life0 self, request: Request<StatRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<StatResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Stat - Get file metadata
Source§

fn readdir<'life0, 'async_trait>( &'life0 self, request: Request<ReaddirRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ReaddirResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Read Directory - List directory contents
Source§

fn watch_file<'life0, 'async_trait>( &'life0 self, request: Request<WatchFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Watch File - Watch file for changes
Source§

fn find_files<'life0, 'async_trait>( &'life0 self, request: Request<FindFilesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<FindFilesResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Find Files - Search for files
Source§

fn find_text_in_files<'life0, 'async_trait>( &'life0 self, request: Request<FindTextInFilesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<FindTextInFilesResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Find Text in Files - Search for text across files
Source§

fn delete_file<'life0, 'async_trait>( &'life0 self, request: Request<DeleteFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Delete File
Source§

fn rename_file<'life0, 'async_trait>( &'life0 self, request: Request<RenameFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Rename File
Source§

fn copy_file<'life0, 'async_trait>( &'life0 self, request: Request<CopyFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Copy File
Source§

fn create_directory<'life0, 'async_trait>( &'life0 self, request: Request<CreateDirectoryRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Create Directory
Source§

fn open_document<'life0, 'async_trait>( &'life0 self, request: Request<OpenDocumentRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<OpenDocumentResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Open Document - Open a document
Source§

fn save_all<'life0, 'async_trait>( &'life0 self, request: Request<SaveAllRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<SaveAllResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Save All - Save all open documents
Source§

fn apply_edit<'life0, 'async_trait>( &'life0 self, request: Request<ApplyEditRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ApplyEditResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Apply Edit - Apply a text edit to a document
Source§

fn update_configuration<'life0, 'async_trait>( &'life0 self, request: Request<UpdateConfigurationRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Update Configuration - Notify of configuration changes
Source§

fn update_workspace_folders<'life0, 'async_trait>( &'life0 self, request: Request<UpdateWorkspaceFoldersRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Update Workspace Folders - Update workspace folders
Source§

fn open_terminal<'life0, 'async_trait>( &'life0 self, request: Request<OpenTerminalRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Open Terminal - Open a new terminal
Source§

fn terminal_input<'life0, 'async_trait>( &'life0 self, request: Request<TerminalInputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Terminal Input - Send input to terminal
Source§

fn close_terminal<'life0, 'async_trait>( &'life0 self, request: Request<CloseTerminalRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Close Terminal - Close a terminal
Source§

fn accept_terminal_opened<'life0, 'async_trait>( &'life0 self, request: Request<TerminalOpenedNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Accept Terminal Opened - Notification: Terminal opened
Source§

fn accept_terminal_closed<'life0, 'async_trait>( &'life0 self, request: Request<TerminalClosedNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Accept Terminal Closed - Notification: Terminal closed
Source§

fn accept_terminal_process_id<'life0, 'async_trait>( &'life0 self, request: Request<TerminalProcessIdNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Accept Terminal Process ID - Notification: Terminal process ID
Source§

fn accept_terminal_process_data<'life0, 'async_trait>( &'life0 self, request: Request<TerminalDataNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Accept Terminal Process Data - Notification: Terminal output
Source§

fn resize_terminal<'life0, 'async_trait>( &'life0 self, request: Request<ResizeTerminalRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Resize Terminal
Source§

fn register_tree_view_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterTreeViewProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Tree View Provider - Register a tree view provider
Source§

fn get_tree_children<'life0, 'async_trait>( &'life0 self, request: Request<GetTreeChildrenRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetTreeChildrenResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get Tree Children - Request tree view children
Source§

fn register_scm_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterScmProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register SCM Provider - Register source control provider
Source§

fn update_scm_group<'life0, 'async_trait>( &'life0 self, request: Request<UpdateScmGroupRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Update SCM Group - Update SCM group
Source§

fn git_exec<'life0, 'async_trait>( &'life0 self, request: Request<GitExecRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GitExecResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Execute Git - Execute git command
Source§

fn register_debug_adapter<'life0, 'async_trait>( &'life0 self, request: Request<RegisterDebugAdapterRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Debug Adapter - Register debug adapter
Source§

fn start_debugging<'life0, 'async_trait>( &'life0 self, request: Request<StartDebuggingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<StartDebuggingResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Start Debugging - Start debug session
Source§

fn stop_debugging<'life0, 'async_trait>( &'life0 self, request: Request<StopDebuggingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Stop Debugging
Source§

fn participate_in_save<'life0, 'async_trait>( &'life0 self, request: Request<ParticipateInSaveRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ParticipateInSaveResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Participate in Save - Extension participates in save
Source§

fn get_secret<'life0, 'async_trait>( &'life0 self, request: Request<GetSecretRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetSecretResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get Secret - Retrieve a secret from storage
Source§

fn store_secret<'life0, 'async_trait>( &'life0 self, request: Request<StoreSecretRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Store Secret - Store a secret in storage
Source§

fn delete_secret<'life0, 'async_trait>( &'life0 self, request: Request<DeleteSecretRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Delete Secret - Delete a secret from storage
Source§

fn register_document_highlight_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Document Highlight Provider
Source§

fn provide_document_highlights<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDocumentHighlightsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentHighlightsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Document Highlights
Source§

fn register_document_symbol_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Document Symbol Provider
Source§

fn provide_document_symbols<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDocumentSymbolsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentSymbolsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Document Symbols
Source§

fn register_workspace_symbol_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Workspace Symbol Provider
Source§

fn provide_workspace_symbols<'life0, 'async_trait>( &'life0 self, request: Request<ProvideWorkspaceSymbolsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideWorkspaceSymbolsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Workspace Symbols
Source§

fn register_rename_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Rename Provider
Source§

fn provide_rename_edits<'life0, 'async_trait>( &'life0 self, request: Request<ProvideRenameEditsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideRenameEditsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Rename Edits
Source§

fn register_document_formatting_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Document Formatting Provider
Source§

fn provide_document_formatting<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDocumentFormattingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentFormattingResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Document Formatting
Source§

fn register_document_range_formatting_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Document Range Formatting Provider
Source§

fn provide_document_range_formatting<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDocumentRangeFormattingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentRangeFormattingResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Document Range Formatting
Source§

fn register_on_type_formatting_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterOnTypeFormattingProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register On Type Formatting Provider
Source§

fn provide_on_type_formatting<'life0, 'async_trait>( &'life0 self, request: Request<ProvideOnTypeFormattingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideOnTypeFormattingResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide On Type Formatting
Source§

fn register_signature_help_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterSignatureHelpProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Signature Help Provider
Source§

fn provide_signature_help<'life0, 'async_trait>( &'life0 self, request: Request<ProvideSignatureHelpRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSignatureHelpResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Signature Help
Source§

fn register_code_lens_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Code Lens Provider
Source§

fn provide_code_lenses<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCodeLensesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCodeLensesResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Code Lenses
Source§

fn register_folding_range_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Folding Range Provider
Source§

fn provide_folding_ranges<'life0, 'async_trait>( &'life0 self, request: Request<ProvideFoldingRangesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideFoldingRangesResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Folding Ranges
Source§

fn register_selection_range_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Selection Range Provider
Source§

fn provide_selection_ranges<'life0, 'async_trait>( &'life0 self, request: Request<ProvideSelectionRangesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSelectionRangesResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Selection Ranges
Source§

fn register_semantic_tokens_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterSemanticTokensProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Semantic Tokens Provider
Source§

fn provide_semantic_tokens_full<'life0, 'async_trait>( &'life0 self, request: Request<ProvideSemanticTokensRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSemanticTokensResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Semantic Tokens Full
Source§

fn register_inlay_hints_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Inlay Hints Provider
Source§

fn provide_inlay_hints<'life0, 'async_trait>( &'life0 self, request: Request<ProvideInlayHintsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideInlayHintsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Inlay Hints
Source§

fn register_type_hierarchy_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Type Hierarchy Provider
Source§

fn provide_type_hierarchy_supertypes<'life0, 'async_trait>( &'life0 self, request: Request<ProvideTypeHierarchyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideTypeHierarchyResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Type Hierarchy Supertypes
Source§

fn provide_type_hierarchy_subtypes<'life0, 'async_trait>( &'life0 self, request: Request<ProvideTypeHierarchyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideTypeHierarchyResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Type Hierarchy Subtypes
Source§

fn register_call_hierarchy_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Call Hierarchy Provider
Source§

fn provide_call_hierarchy_incoming_calls<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCallHierarchyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCallHierarchyResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Call Hierarchy Incoming Calls
Source§

fn provide_call_hierarchy_outgoing_calls<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCallHierarchyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCallHierarchyResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Call Hierarchy Outgoing Calls
Source§

fn register_linked_editing_range_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Linked Editing Range Provider
Source§

fn provide_linked_editing_ranges<'life0, 'async_trait>( &'life0 self, request: Request<ProvideLinkedEditingRangesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideLinkedEditingRangesResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Provide Linked Editing Ranges
Source§

fn show_quick_pick<'life0, 'async_trait>( &'life0 self, request: Request<ShowQuickPickRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowQuickPickResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Show Quick Pick
Source§

fn show_input_box<'life0, 'async_trait>( &'life0 self, request: Request<ShowInputBoxRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowInputBoxResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Show Input Box
Source§

fn show_progress<'life0, 'async_trait>( &'life0 self, request: Request<ShowProgressRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowProgressResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Show Progress
Source§

fn report_progress<'life0, 'async_trait>( &'life0 self, request: Request<ReportProgressRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Report Progress
Source§

fn open_external<'life0, 'async_trait>( &'life0 self, request: Request<OpenExternalRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Open External URI
Source§

fn create_output_channel<'life0, 'async_trait>( &'life0 self, request: Request<CreateOutputChannelRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateOutputChannelResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Create Output Channel
Source§

fn append_output<'life0, 'async_trait>( &'life0 self, request: Request<AppendOutputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Append to Output Channel
Source§

fn clear_output<'life0, 'async_trait>( &'life0 self, request: Request<ClearOutputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Clear Output Channel
Source§

fn show_output<'life0, 'async_trait>( &'life0 self, request: Request<ShowOutputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Show Output Channel
Source§

fn dispose_output<'life0, 'async_trait>( &'life0 self, request: Request<DisposeOutputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Dispose Output Channel
Source§

fn register_task_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterTaskProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Task Provider
Source§

fn execute_task<'life0, 'async_trait>( &'life0 self, request: Request<ExecuteTaskRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ExecuteTaskResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Execute Task
Source§

fn terminate_task<'life0, 'async_trait>( &'life0 self, request: Request<TerminateTaskRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Terminate Task
Source§

fn get_authentication_session<'life0, 'async_trait>( &'life0 self, request: Request<GetAuthenticationSessionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetAuthenticationSessionResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get Authentication Session
Source§

fn register_authentication_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterAuthenticationProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Register Authentication Provider
Source§

fn get_extension<'life0, 'async_trait>( &'life0 self, request: Request<GetExtensionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetExtensionResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get Extension
Source§

fn get_all_extensions<'life0, 'async_trait>( &'life0 self, request: Request<Empty>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetAllExtensionsResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get All Extensions
Source§

fn get_configuration<'life0, 'async_trait>( &'life0 self, request: Request<GetConfigurationRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetConfigurationResponse>, Status>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get Configuration Value

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FromRef<T> for T
where T: Clone,

§

fn from_ref(input: &T) -> T

Converts to this type from a reference to the input type.
§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> IntoRequest<T> for T

§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<L> LayerExt<L> for L

§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in [Layered].
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
Source§

impl<T> AutoreleaseSafe for T
where T: ?Sized,