VectorOperators.Conversion (Java SE 26 & JDK 26)
Description: declaration: module: jdk.incubator.vector, package: jdk.incubator.vector, class: VectorOperators, interface: Conversion
Keywords: jdk.incubator.vector.VectorOperators.Conversion interface

# Interface VectorOperators.Conversion<E,F>

Type Parameters:
  `E` - the boxed element type for the conversion domain type (the input lane type)
  `F` - the boxed element type for the conversion range type (the output lane type)

All Superinterfaces:
  `VectorOperators.Operator`

Enclosing class:
  `VectorOperators`

public static interface VectorOperators.Conversion<E,F> extends VectorOperators.Operator
Type for all lane-wise conversions on lane values, usable in expressions like `w1 = v0.` `convert``(I2D, 1)`.

API Note:
  User code should not implement this interface. A future release of this type may restrict implementations to be members of the same package.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `<E,F> VectorOperators.Conversion<E,F>`
  `check(Class<E> from, Class<F> to)`
  Ensures that this conversion has the desired domain and range types.
  `Class<E>`
  `domainType()`
  The domain of this conversion, a primitive type.
  `static <E,F> VectorOperators.Conversion<E,F>`
  `ofCast(Class<E> from, Class<F> to)`
  The Java language assignment or casting conversion between two types.
  `static <E,F> VectorOperators.Conversion<E,F>`
  `ofReinterpret(Class<E> from, Class<F> to)`
  The bitwise reinterpretation between two types.
  `Class<F>`
  `rangeType()`
  The range of this conversion, a primitive type.

  ### Methods declared in interface VectorOperators.Operator

  `arity, compatibleWith, isAssociative, isBoolean, name, operatorName`
  Modifier and Type
  Method
  Description
  `int`
  `arity()`
  Returns the arity of this operator (1, 2, or 3).
  `boolean`
  `compatibleWith(Class<?> elementType)`
  Reports whether this operator is compatible with the proposed element type.
  `boolean`
  `isAssociative()`
  Returns the associativity of this operator.
  `boolean`
  `isBoolean()`
  Reports whether this operator returns a boolean (a mask).
  `String`
  `name()`
  Returns the symbolic name of this operator, as a constant in `VectorOperators`.
  `String`
  `operatorName()`
  Returns the Java operator symbol or method name corresponding to this operator.

- ## Method Details

  - ### domainType

    Class<E> domainType()
    The domain of this conversion, a primitive type.
    Returns:
      the domain of this conversion

  - ### rangeType

    Class<F> rangeType()
    The range of this conversion, a primitive type.
    Specified by:
      `rangeType` in interface `VectorOperators.Operator`
    Returns:
      the range of this conversion

  - ### check

    <E,F> VectorOperators.Conversion<E,F> check(Class<E> from, Class<F> to)
    Ensures that this conversion has the desired domain and range types.
    Type Parameters:
      `E` - the desired domain type
      `F` - the desired range type
    Parameters:
      `from` - the desired domain type
      `to` - the desired range type
    Returns:
      this conversion object, with validated domain and range

  - ### ofCast

    static <E,F> VectorOperators.Conversion<E,F> ofCast(Class<E> from, Class<F> to)
    The Java language assignment or casting conversion between two types.
    Type Parameters:
      `E` - the domain type (boxed version of a lane type)
      `F` - the range type (boxed version of a lane type)
    Parameters:
      `from` - the type of the value to convert
      `to` - the desired type after conversion
    Returns:
      a Java assignment or casting conversion

  - ### ofReinterpret

    static <E,F> VectorOperators.Conversion<E,F> ofReinterpret(Class<E> from, Class<F> to)
    The bitwise reinterpretation between two types.
    Type Parameters:
      `E` - the domain type (boxed version of a lane type)
      `F` - the range type (boxed version of a lane type)
    Parameters:
      `from` - the type of the value to reinterpret
      `to` - the desired type after reinterpretation
    Returns:
      a bitwise reinterpretation conversion