# Enum ocl::builders::DeviceSpecifier [−] [src]

    pub enum DeviceSpecifier {
        All,
        First,
        Single(Device),
        List(Vec<Device>),
        Indices(Vec<usize>),
        WrappingIndices(Vec<usize>),
        TypeFlags(DeviceType),
    }

Specifies [what boils down to] a list of devices.

The `Indices` variant is context-specific, not robust, and may lead to a panic if the context changes. It is useful for convenience only and not recommended for general use. The `WrappingIndices` variant is somewhat less dangerous but can still be somewhat machine-specific.

The `TypeFlags` variant is used for specifying a list of devices using a bitfield (`DeviceType`) and is the most robust / portable.

[FIXME: Add some links to the SDK]

## Variants

`All` `First` `Single(Device)` `List(Vec<Device>)` `Indices(Vec<usize>)` `WrappingIndices(Vec<usize>)` `TypeFlags(DeviceType)`

## Methods

### `impl DeviceSpecifier`
[src]

#### `pub fn all(self) -> DeviceSpecifier`
[src]

Returns a `DeviceSpecifier::All` variant which specifies all devices on a platform.

#### `pub fn first(self) -> DeviceSpecifier`
[src]

Returns a `DeviceSpecifier::First` variant which specifies only the first device on a platform.

#### `pub fn single(self, device: Device) -> DeviceSpecifier`
[src]

Returns a `DeviceSpecifier::Single` variant which specifies a single device.

#### `pub fn list(self, list: Vec<Device>) -> DeviceSpecifier`
[src]

Returns a `DeviceSpecifier::List` variant which specifies a list of devices.

#### `pub unsafe fn indices(self, indices: Vec<usize>) -> DeviceSpecifier`
[src]

Returns a `DeviceSpecifier::Indices` variant which specifies a list of devices by index.

### Safety

This variant is context-specific, not robust, and may lead to a panic if the context changes. It is useful for convenience only and not recommended for general use.

Though using the `Indices` variant is not strictly unsafe in the usual way (will not lead to memory bugs, etc.), it is marked unsafe as a warning. Recommendations for a more idiomatic way to express this potential footgun are welcome.

Using `::wrapping_indices` is a more robust (but still potentially non-portable) solution.

#### `pub fn wrapping_indices(self, windices: Vec<usize>) -> DeviceSpecifier`
[src]

Returns a `DeviceSpecifier::WrappingIndices` variant, specifying a list of devices by indices which are wrapped around (simply using the modulo operator) so that every index is always valid.

#### `pub fn type_flags(self, flags: DeviceType) -> DeviceSpecifier`
[src]

Returns a `DeviceSpecifier::TypeFlags` variant which specifies a list of devices using a conventional bitfield.

#### `pub fn to_device_list<P: Borrow<Platform>>(
&self,
platform: Option<P>
) -> OclResult<Vec<Device>>`
[src]

Returns the list of devices matching the parameters specified by this `DeviceSpecifier`

### Panics

Any device indices listed within the `Indices` variant must be within the range of the number of devices for the platform specified by `Platform`. If no `platform` has been specified, this behaviour is undefined and could end up using any platform at all.

## Trait Implementations

### `impl Debug for DeviceSpecifier`
[src]

#### `fn fmt(&self, __arg_0: &mut Formatter) -> Result`
[src]

Formats the value using the given formatter. Read more

### `impl Clone for DeviceSpecifier`
[src]

#### `fn clone(&self) -> DeviceSpecifier`
[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`
1.0.0
[src]

Performs copy-assignment from `source`. Read more

### `impl Default for DeviceSpecifier`
[src]

#### `fn default() -> DeviceSpecifier`
[src]

Returns the "default value" for a type. Read more

### `impl From<usize> for DeviceSpecifier`
[src]

#### `fn from(index: usize) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl<'a> From<&'a [usize]> for DeviceSpecifier`
[src]

#### `fn from(indices: &'a [usize]) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl<'a> From<&'a Vec<usize>> for DeviceSpecifier`
[src]

#### `fn from(indices: &'a Vec<usize>) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl<'a> From<&'a [Device]> for DeviceSpecifier`
[src]

#### `fn from(devices: &'a [Device]) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl<'a> From<&'a Vec<Device>> for DeviceSpecifier`
[src]

#### `fn from(devices: &'a Vec<Device>) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl From<Device> for DeviceSpecifier`
[src]

#### `fn from(device: Device) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl<'a> From<&'a Device> for DeviceSpecifier`
[src]

#### `fn from(device: &'a Device) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl From<DeviceIdCore> for DeviceSpecifier`
[src]

#### `fn from(device: DeviceIdCore) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl<'a> From<&'a DeviceIdCore> for DeviceSpecifier`
[src]

#### `fn from(device: &'a DeviceIdCore) -> DeviceSpecifier`
[src]

Performs the conversion.

### `impl From<DeviceType> for DeviceSpecifier`
[src]

#### `fn from(flags: DeviceType) -> DeviceSpecifier`
[src]

Performs the conversion.

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)