Enum ocl::enums::DeviceSpecifier

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

AllFirstSingle(Device)List(Vec<Device>)Indices(Vec<usize>)WrappingIndices(Vec<usize>)TypeFlags(DeviceType)

Methods

impl DeviceSpecifier

fn all(self) -> DeviceSpecifier

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

fn first(self) -> DeviceSpecifier

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

fn single(self, device: Device) -> DeviceSpecifier

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

fn list(self, list: Vec<Device>) -> DeviceSpecifier

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

unsafe fn indices(self, indices: Vec<usize>) -> DeviceSpecifier

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.

fn wrapping_indices(self, windices: Vec<usize>) -> DeviceSpecifier

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.

fn type_flags(self, flags: DeviceType) -> DeviceSpecifier

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

fn to_device_list<P: Borrow<Platform>>(
    &self,
    platform: Option<P>
) -> OclResult<Vec<Device>>

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

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Clone for DeviceSpecifier

fn clone(&self) -> DeviceSpecifier

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for DeviceSpecifier

fn default() -> DeviceSpecifier

Returns the "default value" for a type.

impl From<usize> for DeviceSpecifier

fn from(index: usize) -> DeviceSpecifier

Performs the conversion.

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

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

Performs the conversion.

impl<'a> From<&'a Vec<usize>> for DeviceSpecifier

fn from(indices: &'a Vec<usize>) -> DeviceSpecifier

Performs the conversion.

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

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

Performs the conversion.

impl<'a> From<&'a Vec<Device>> for DeviceSpecifier

fn from(devices: &'a Vec<Device>) -> DeviceSpecifier

Performs the conversion.

impl From<Device> for DeviceSpecifier

fn from(device: Device) -> DeviceSpecifier

Performs the conversion.

impl<'a> From<&'a Device> for DeviceSpecifier

fn from(device: &'a Device) -> DeviceSpecifier

Performs the conversion.

impl From<DeviceType> for DeviceSpecifier

fn from(flags: DeviceType) -> DeviceSpecifier

Performs the conversion.