# Struct ocl::flags::MapFlags [−]

    pub struct MapFlags { /* fields omitted */ }

cl_map_flags - bitfield

## Methods

### `impl MapFlags`
[src]

#### `pub fn new() -> MapFlags`
[src]

#### `pub fn read(self) -> MapFlags`
[src]

#### `pub fn write(self) -> MapFlags`
[src]

#### `pub fn write_invalidate_region(self) -> MapFlags`
[src]

### `impl MapFlags`

#### `pub const READ: MapFlags`

    READ: MapFlags = MapFlags{bits: 1 << 0,}

#### `pub const WRITE: MapFlags`

    WRITE: MapFlags = MapFlags{bits: 1 << 1,}

#### `pub const WRITE_INVALIDATE_REGION: MapFlags`

    WRITE_INVALIDATE_REGION: MapFlags = MapFlags{bits: 1 << 2,}

#### `pub fn empty() -> MapFlags`

Returns an empty set of flags.

#### `pub fn all() -> MapFlags`

Returns the set containing all flags.

#### `pub fn bits(&self) -> u64`

Returns the raw value of the flags currently stored.

#### `pub fn from_bits(bits: u64) -> Option<MapFlags>`

Convert from underlying bit representation, unless that representation contains bits that do not correspond to a flag.

#### `pub fn from_bits_truncate(bits: u64) -> MapFlags`

Convert from underlying bit representation, dropping any bits that do not correspond to flags.

#### `pub fn is_empty(&self) -> bool`

Returns `true` if no flags are currently stored.

#### `pub fn is_all(&self) -> bool`

Returns `true` if all flags are currently set.

#### `pub fn intersects(&self, other: MapFlags) -> bool`

Returns `true` if there are flags common to both `self` and `other`.

#### `pub fn contains(&self, other: MapFlags) -> bool`

Returns `true` all of the flags in `other` are contained within `self`.

#### `pub fn insert(&mut self, other: MapFlags)`

Inserts the specified flags in-place.

#### `pub fn remove(&mut self, other: MapFlags)`

Removes the specified flags in-place.

#### `pub fn toggle(&mut self, other: MapFlags)`

Toggles the specified flags in-place.

#### `pub fn set(&mut self, other: MapFlags, value: bool)`

Inserts or removes the specified flags depending on the passed value.

## Trait Implementations

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

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

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

### `impl Eq for MapFlags`

### `impl PartialEq<MapFlags> for MapFlags`

#### `fn eq(&self, __arg_0: &MapFlags) -> bool`

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `fn ne(&self, __arg_0: &MapFlags) -> bool`

This method tests for `!=`.

### `impl LowerHex for MapFlags`

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter.

### `impl BitOrAssign<MapFlags> for MapFlags`

#### `fn bitor_assign(&mut self, other: MapFlags)`

Adds the set of flags.

### `impl BitAndAssign<MapFlags> for MapFlags`

#### `fn bitand_assign(&mut self, other: MapFlags)`

Disables all flags disabled in the set.

### `impl Binary for MapFlags`

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter.

### `impl BitOr<MapFlags> for MapFlags`

#### `type Output = MapFlags`

The resulting type after applying the `|` operator.

#### `fn bitor(self, other: MapFlags) -> MapFlags`

Returns the union of the two sets of flags.

### `impl Hash for MapFlags`

#### `fn hash<__H>(&self, __arg_0: &mut __H) where
__H: Hasher,`

Feeds this value into the given [`Hasher`]. Read more

#### `fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,`
1.3.0
[src]

Feeds a slice of this type into the given [`Hasher`]. Read more

### `impl Extend<MapFlags> for MapFlags`

#### `fn extend<T>(&mut self, iterator: T) where
T: IntoIterator<Item = MapFlags>,`

Extends a collection with the contents of an iterator. Read more

### `impl BitXor<MapFlags> for MapFlags`

#### `type Output = MapFlags`

The resulting type after applying the `^` operator.

#### `fn bitxor(self, other: MapFlags) -> MapFlags`

Returns the left flags, but with all the right flags toggled.

### `impl Clone for MapFlags`

#### `fn clone(&self) -> MapFlags`

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 SubAssign<MapFlags> for MapFlags`

#### `fn sub_assign(&mut self, other: MapFlags)`

Disables all flags enabled in the set.

### `impl Not for MapFlags`

#### `type Output = MapFlags`

The resulting type after applying the `!` operator.

#### `fn not(self) -> MapFlags`

Returns the complement of this set of flags.

### `impl Ord for MapFlags`

#### `fn cmp(&self, __arg_0: &MapFlags) -> Ordering`

This method returns an `Ordering` between `self` and `other`. Read more

#### `fn max(self, other: Self) -> Self`
1.21.0
[src]

Compares and returns the maximum of two values. Read more

#### `fn min(self, other: Self) -> Self`
1.21.0
[src]

Compares and returns the minimum of two values. Read more

### `impl Sub<MapFlags> for MapFlags`

#### `type Output = MapFlags`

The resulting type after applying the `-` operator.

#### `fn sub(self, other: MapFlags) -> MapFlags`

Returns the set difference of the two sets of flags.

### `impl UpperHex for MapFlags`

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter.

### `impl Copy for MapFlags`

### `impl PartialOrd<MapFlags> for MapFlags`

#### `fn partial_cmp(&self, __arg_0: &MapFlags) -> Option<Ordering>`

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `fn lt(&self, __arg_0: &MapFlags) -> bool`

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `fn le(&self, __arg_0: &MapFlags) -> bool`

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `fn gt(&self, __arg_0: &MapFlags) -> bool`

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `fn ge(&self, __arg_0: &MapFlags) -> bool`

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl Debug for MapFlags`

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter. Read more

### `impl BitXorAssign<MapFlags> for MapFlags`

#### `fn bitxor_assign(&mut self, other: MapFlags)`

Toggles the set of flags.

### `impl Octal for MapFlags`

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter.

### `impl BitAnd<MapFlags> for MapFlags`

#### `type Output = MapFlags`

The resulting type after applying the `&` operator.

#### `fn bitand(self, other: MapFlags) -> MapFlags`

Returns the intersection between the two sets of flags.

### `impl FromIterator<MapFlags> for MapFlags`

#### `fn from_iter<T>(iterator: T) -> MapFlags where
T: IntoIterator<Item = MapFlags>,`

Creates a value from an iterator. Read more

# 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`)