Struct Use

pub struct Use {

    pub service: Option<OneOrMany<Name>>,
    pub protocol: Option<OneOrMany<Name>>,
    pub directory: Option<Name>,
    pub storage: Option<Name>,
    pub event_stream: Option<OneOrMany<Name>>,
    pub runner: Option<Name>,
    pub config: Option<Name>,
    pub from: Option<UseFromRef>,
    pub path: Option<Path>,
    pub rights: Option<Rights>,
    pub subdir: Option<RelativePath>,
    pub scope: Option<OneOrMany<EventScope>>,
    pub filter: Option<Map<String, Value>>,
    pub dependency: Option<DependencyType>,
    pub availability: Option<Availability>,
    pub key: Option<Name>,
    pub config_type: Option<ConfigType>,
    pub config_max_size: Option<NonZeroU32>,
    pub config_max_count: Option<NonZeroU32>,
    pub config_element_type: Option<ConfigNestedValueType>,
    pub config_default: Option<Value>,
}

Example:

use: [
    {
        protocol: [
            "fuchsia.ui.scenic.Scenic",
            "fuchsia.accessibility.Manager",
        ]
    },
    {
        directory: "themes",
        path: "/data/themes",
        rights: [ "r*" ],
    },
    {
        storage: "persistent",
        path: "/data",
    },
    {
        event_stream: [
            "started",
            "stopped",
        ],
        from: "framework",
    },
    {
        runner: "own_test_runner".
        from: "#test_runner",
    },
],

Fields

service: Option<OneOrMany<Name>>

When using a service capability, the name of a [service capability][doc-service].

protocol: Option<OneOrMany<Name>>

When using a protocol capability, the name of a [protocol capability][doc-protocol].

directory: Option<Name>

When using a directory capability, the name of a [directory capability][doc-directory].

storage: Option<Name>

When using a storage capability, the name of a [storage capability][doc-storage].

event_stream: Option<OneOrMany<Name>>

When using an event stream capability, the name of an [event stream capability][doc-event].

runner: Option<Name>

When using a runner capability, the name of a [runner capability][doc-runners].

config: Option<Name>

When using a configuration capability, the name of a [configuration capability][doc-configuration].

from: Option<UseFromRef>

The source of the capability. Defaults to parent. One of:

• parent: The component’s parent.
• debug: One of debug_capabilities in the environment assigned to this component.
• framework: The Component Framework runtime.
• self: This component.
• #<capability-name>: The name of another capability from which the requested capability is derived.
• #<child-name>: A reference to a child component instance.

path: Option<Path>

The path at which to install the capability in the component’s namespace. For protocols, defaults to /svc/${protocol}. Required for directory and storage. This property is disallowed for declarations with arrays of capability names and for runner capabilities.

rights: Option<Rights>

(directory only) the maximum [directory rights][doc-directory-rights] to apply to the directory in the component’s namespace.

subdir: Option<RelativePath>

(directory only) A subdirectory within the directory capability to provide in the component’s namespace.

scope: Option<OneOrMany<EventScope>>

(event_stream only) When defined the event stream will contain events about only the components defined in the scope.

filter: Option<Map<String, Value>>

(event_stream only) Capability requested event streams require specifying a filter referring to the protocol to which the events in the event stream apply. The content of the filter will be an object mapping from “name” to the “protocol name”.

dependency: Option<DependencyType>

The type of dependency between the source and this component, one of:

• strong: a strong dependency, which is used to determine shutdown ordering. Component manager is guaranteed to stop the target before the source. This is the default.
• weak: a weak dependency, which is ignored during shutdown. When component manager stops the parent realm, the source may stop before the clients. Clients of weak dependencies must be able to handle these dependencies becoming unavailable. This property is disallowed for runner capabilities, which are always a strong dependency.

availability: Option<Availability>

The expectations around this capability’s availability. One of:

• required (default): a required dependency, the component is unable to perform its work without this capability.
• optional: an optional dependency, the component will be able to function without this capability (although if the capability is unavailable some functionality may be disabled).
• transitional: the source may omit the route completely without even having to route from void. Used for soft transitions that introduce new capabilities. This property is disallowed for runner capabilities, which are always required.

For more information, see the availability documentation.

key: Option<Name>

(config only) The configuration key in the component’s config block that this capability will set.

config_type: Option<ConfigType>

(config only) The type of configuration, one of:

• bool: Boolean type.
• uint8: Unsigned 8 bit type.
• uint16: Unsigned 16 bit type.
• uint32: Unsigned 32 bit type.
• uint64: Unsigned 64 bit type.
• int8: Signed 8 bit type.
• int16: Signed 16 bit type.
• int32: Signed 32 bit type.
• int64: Signed 64 bit type.
• string: ASCII string type.
• vector: Vector type. See element for the type of the element within the vector

config_max_size: Option<NonZeroU32>

(configuration only) Only supported if this configuration type is ‘string’. This is the max size of the string.

config_max_count: Option<NonZeroU32>

(configuration only) Only supported if this configuration type is ‘vector’. This is the max number of elements in the vector.

config_element_type: Option<ConfigNestedValueType>

(configuration only) Only supported if this configuration type is ‘vector’. This is the type of the elements in the configuration vector.

Example (simple type):

{ type: "uint8" }

Example (string type):

{
  type: "string",
  max_size: 100,
}

config_default: Option<Value>

(configuration only) The default value of this configuration. Default values are used if the capability is optional and routed from void. This is only supported if availability is not `required``.

Trait Implementations

impl CapabilityClause for Use

fn service(&self) -> Option<OneOrMany<&Name>>

fn protocol(&self) -> Option<OneOrMany<&Name>>

fn directory(&self) -> Option<OneOrMany<&Name>>

fn storage(&self) -> Option<OneOrMany<&Name>>

fn runner(&self) -> Option<OneOrMany<&Name>>

fn resolver(&self) -> Option<OneOrMany<&Name>>

fn event_stream(&self) -> Option<OneOrMany<&Name>>

fn dictionary(&self) -> Option<OneOrMany<&Name>>

fn config(&self) -> Option<OneOrMany<&Name>>

fn set_service(&mut self, o: Option<OneOrMany<Name>>)

fn set_protocol(&mut self, o: Option<OneOrMany<Name>>)

fn set_directory(&mut self, o: Option<OneOrMany<Name>>)

fn set_storage(&mut self, o: Option<OneOrMany<Name>>)

fn set_runner(&mut self, _o: Option<OneOrMany<Name>>)

fn set_resolver(&mut self, _o: Option<OneOrMany<Name>>)

fn set_event_stream(&mut self, o: Option<OneOrMany<Name>>)

fn set_dictionary(&mut self, _o: Option<OneOrMany<Name>>)

fn set_config(&mut self, o: Option<OneOrMany<Name>>)

fn availability(&self) -> Option<Availability>

fn set_availability(&mut self, a: Option<Availability>)

fn decl_type(&self) -> &'static str

fn supported(&self) -> &[&'static str]

fn are_many_names_allowed(&self) -> bool

Returns true if this capability type allows the ::Many variant of OneOrMany.

fn capability_type(&self) -> Result<&'static str, Error>

Returns the name of the capability for display purposes. If service() returns Some, the capability name must be “service”, etc.

fn names(&self) -> Vec<&Name>

Returns the names of the capabilities in this clause. If protocol() returns Some(OneOrMany::Many(vec!["a", "b"])), this returns![“a”, “b”].

fn set_names(&mut self, names: Vec<Name>)

impl Clone for Use

fn clone(&self) -> Use

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Use

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

Formats the value using the given formatter.

impl Default for Use

fn default() -> Use

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Use

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FilterClause for Use

fn filter(&self) -> Option<&Map<String, Value>>

impl FromClause for Use

fn from_(&self) -> OneOrMany<AnyRef<'_>>

impl MarkdownReferenceDocGenerator for Use

fn get_reference_doc_markdown() -> String

Returns a Markdown representation of the reference docs for the struct that is derived from ReferenceDoc. The returned Markdown indents any # Markdown headers in individual field doc comments to ensure a well structured final Markdown document.

fn get_reference_doc_markdown_with_options( indent_headers_by: usize, indent_with_spaces: usize, ) -> String

This method is called internally by the reference doc generator when recursing to generate documentation for field types.

impl PartialEq for Use

fn eq(&self, other: &Use) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PathClause for Use

fn path(&self) -> Option<&Path>

impl RightsClause for Use

fn rights(&self) -> Option<&Rights>

impl Serialize for Use

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Use