Trait OperationDeclaration 

pub trait OperationDeclaration: 'static {
    type Request: Portable;
    type Response: Portable;
    type Input: Direction;
    type Output: Direction;

    const ID: &'static str;
    const POLICY: OperationPolicy;
    const DESCRIPTION: &'static str = "";
    const VISIBILITY: Visibility = Visibility::Private;
    const REPLAY: ReplaySafety = ReplaySafety::Unknown;
    const GRPC: Option<Grpc> = None;
    const OPERATIONS: &'static [WireDeclaration] = _;

    // Provided methods
    fn definition() -> OperationDefinition { ... }
    fn grant(_request: &Self::Request) -> Option<Grant> { ... }
    fn key(_request: &Self::Request) -> Option<CacheKey> { ... }
}

Required Associated Constants

const ID: &'static str

const POLICY: OperationPolicy

Provided Associated Constants

const DESCRIPTION: &'static str = ""

const VISIBILITY: Visibility = Visibility::Private

const REPLAY: ReplaySafety = ReplaySafety::Unknown

const GRPC: Option<Grpc> = None

const OPERATIONS: &'static [WireDeclaration] = _

Required Associated Types

type Request: Portable

type Response: Portable

type Input: Direction

type Output: Direction

Provided Methods

fn definition() -> OperationDefinition

fn grant(_request: &Self::Request) -> Option<Grant>

fn key(_request: &Self::Request) -> Option<CacheKey>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl OperationDeclaration for AbandonFile

const ID: &'static str = "storage.abandon_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = AbandonFile

type Response = FileProgress

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for AppendFile

const ID: &'static str = "storage.append_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = AppendFile

type Response = FileProducer

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for Cancel

const ID: &'static str = "host.operations.cancel"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = super::POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const GRPC: Option<Grpc>

type Request = Cancel

type Response = InstanceState

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for CaptureFile

const ID: &'static str = "storage.capture_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Unknown

const GRPC: Option<Grpc>

type Request = CaptureFile

type Response = FileReference

type Input = NoStream

type Output = NoStream

fn grant( request: &<CaptureFile as OperationDeclaration>::Request, ) -> Option<Grant>

impl OperationDeclaration for Catalog

const ID: &'static str = "host.catalog"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = super::POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const GRPC: Option<Grpc>

type Request = Catalog

type Response = CatalogPage

type Input = NoStream

type Output = NoStream

fn grant(request: &<Catalog as OperationDeclaration>::Request) -> Option<Grant>

impl OperationDeclaration for CreateFile

const ID: &'static str = "storage.create_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = CreateFile

type Response = FileProducer

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for DeleteFile

const ID: &'static str = "storage.delete_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = DeleteFile

type Response = StagedFile

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for FinishFile

const ID: &'static str = "storage.finish_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = FinishFile

type Response = FileReference

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for FollowFile

const ID: &'static str = "storage.follow_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const GRPC: Option<Grpc>

type Request = FollowFile

type Response = FileCompletion

type Input = NoStream

type Output = Stream<FileEvent>

fn grant( request: &<FollowFile as OperationDeclaration>::Request, ) -> Option<Grant>

impl OperationDeclaration for FollowObjects

const ID: &'static str = "storage.follow_objects"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = STREAM_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

type Request = FollowObjects

type Response = StorageCursor

type Input = NoStream

type Output = Stream<ObjectEntry>

impl OperationDeclaration for FollowProduction

const ID: &'static str = "storage.follow_production"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Unknown

const GRPC: Option<Grpc>

type Request = FollowProduction

type Response = FileProgress

type Input = NoStream

type Output = Stream<FileBatch>

fn grant( request: &<FollowProduction as OperationDeclaration>::Request, ) -> Option<Grant>

impl OperationDeclaration for FollowRecords

const ID: &'static str = "storage.follow_records"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = super::STREAM_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const GRPC: Option<Grpc>

type Request = FollowRecords

type Response = StorageCursor

type Input = NoStream

type Output = Stream<Followed>

fn grant( request: &<FollowRecords as OperationDeclaration>::Request, ) -> Option<Grant>

impl OperationDeclaration for FollowStream

const ID: &'static str = "storage.follow_stream"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = STREAM_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

type Request = FollowStream

type Response = StorageCursor

type Input = NoStream

type Output = Stream<StoredRow>

impl OperationDeclaration for HashFile

const ID: &'static str = "storage.hash_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

const GRPC: Option<Grpc>

type Request = HashFile

type Response = FileHash

type Input = NoStream

type Output = NoStream

fn grant(request: &<HashFile as OperationDeclaration>::Request) -> Option<Grant>

impl OperationDeclaration for Initialize

const ID: &'static str = "harmos.initialize"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = super::POLICY

type Request = Initialize

type Response = ()

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for ListDirectory

const ID: &'static str = "storage.list_directory"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

const GRPC: Option<Grpc>

type Request = ListDirectory

type Response = DirectoryCompletion

type Input = NoStream

type Output = Stream<DirectoryEntry>

impl OperationDeclaration for Publish

const ID: &'static str = "host.publish"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = crate::host::POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

type Request = Publish

type Response = ()

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for Query

const ID: &'static str = "storage.query"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

const GRPC: Option<Grpc>

type Request = Query

type Response = QueryCompletion

type Input = NoStream

type Output = Stream<QueryOutput>

fn grant(request: &<Query as OperationDeclaration>::Request) -> Option<Grant>

impl OperationDeclaration for ReadFile

const ID: &'static str = "storage.read_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

const GRPC: Option<Grpc>

type Request = ReadFile

type Response = FileCompletion

type Input = NoStream

type Output = Stream<FileBatch>

fn grant(request: &<ReadFile as OperationDeclaration>::Request) -> Option<Grant>

impl OperationDeclaration for ResumeFile

const ID: &'static str = "storage.resume_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = ResumeFile

type Response = FileProducer

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for Shutdown

const ID: &'static str = "harmos.shutdown"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = super::POLICY

type Request = Shutdown

type Response = ()

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for Status

const ID: &'static str = "host.operations.status"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = super::POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const GRPC: Option<Grpc>

type Request = Status

type Response = InstanceState

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for StorageStatus

const ID: &'static str = "storage.status"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = StorageStatus

type Response = StorageInfo

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for Watch

const ID: &'static str = "host.operations.watch"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = super::WATCH_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const GRPC: Option<Grpc>

type Request = Watch

type Response = InstanceState

type Input = NoStream

type Output = Stream<InstanceState>

impl OperationDeclaration for WatchDirectory

const ID: &'static str = "storage.watch_directory"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

const GRPC: Option<Grpc>

type Request = WatchDirectory

type Response = DirectoryCompletion

type Input = NoStream

type Output = Stream<DirectoryEvent>

impl OperationDeclaration for WriteFile

const ID: &'static str = "storage.write_file"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Unknown

const GRPC: Option<Grpc>

type Request = WriteFile

type Response = FileReference

type Input = Stream<FileBatch>

type Output = NoStream

fn grant( request: &<WriteFile as OperationDeclaration>::Request, ) -> Option<Grant>

impl OperationDeclaration for WriteObjects

const ID: &'static str = "storage.write_objects"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Unknown

const GRPC: Option<Grpc>

type Request = WriteObjects

type Response = WriteCompletion

type Input = Stream<DataBatch>

type Output = Stream<WriteReceipt>

impl OperationDeclaration for WriteRecords

const ID: &'static str = "storage.write_records"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Unknown

const GRPC: Option<Grpc>

type Request = WriteRecords

type Response = WriteCompletion

type Input = Stream<DataBatch>

type Output = Stream<WriteReceipt>

impl OperationDeclaration for WriteSchema

const ID: &'static str = "storage.write_schema"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = WriteSchema

type Response = StorageCursor

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for WriteStreams

const ID: &'static str = "storage.write_streams"

const OPERATIONS: &'static [WireDeclaration]

const POLICY: OperationPolicy = IO_POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

const REPLAY: ReplaySafety = ReplaySafety::Unknown

const GRPC: Option<Grpc>

type Request = WriteStreams

type Response = WriteCompletion

type Input = Stream<DataBatch>

type Output = Stream<WriteReceipt>

Implementors

impl OperationDeclaration for Activation

const ID: &'static str = ""

const POLICY: OperationPolicy

type Request = ()

type Response = ()

type Input = NoStream

type Output = NoStream

impl OperationDeclaration for Control

const ID: &'static str = "harmos_observe"

const POLICY: OperationPolicy = POLICY

const VISIBILITY: Visibility = Visibility::Host

const REPLAY: ReplaySafety = ReplaySafety::Idempotent

type Request = ControlRequest

type Response = ()

type Input = NoStream

type Output = NoStream

impl<L> OperationDeclaration for Callback<L>

where L: Listener,

const ID: &'static str = L::CALLBACK

const POLICY: OperationPolicy = L::POLICY

const VISIBILITY: Visibility = crate::operations::Visibility::Shared

type Request = Delivery<L>

type Response = ()

type Input = NoStream

type Output = NoStream