Package org.spongepowered.asm.mixin.injection

## Annotation Type Constant

-     @Target({})
      @Retention(RUNTIME)
      public @interface Constant

  Annotation for specifying the injection point for an `ModifyConstant` injector. Leaving all values unset causes the injection point to match all constants with the same type as the `ModifyConstant` handler's return type.

  To match a specific constant, specify the appropriate value for the appropriate argument. Specifying values of different types will cause an error to be raised by the injector.

- - ### Optional Element Summary

    Optional Elements
    Modifier and Type | Optional Element | Description
    --- | --- | ---
    `java.lang.Class<?>` | `classValue` | Specify a type literal to match
    `double` | `doubleValue` | Specify a double constant to match
    `Constant.Condition[]` | `expandZeroConditions` | Whilst most constants can be located in the compiled method with relative ease, there exists a special case when a `zero` is used in a conditional expression.
    `float` | `floatValue` | Specify a float constant to match
    `int` | `intValue` | Specify an integer constant to match, includes byte and short values.
    `boolean` | `log` |
    `long` | `longValue` | Specify a long constant to match
    `boolean` | `nullValue` | Causes this injector to match `ACONST_NULL` (null object) literals
    `int` | `ordinal` | Ordinal offset.
    `java.lang.String` | `slice` | This specifies the ID of the slice to use for this query.
    `java.lang.String` | `stringValue` | Specify a String constant to match

- - ### Element Detail

    - #### nullValue

          boolean nullValue

      Causes this injector to match `ACONST_NULL` (null object) literals
      Returns:
        true to match `null`
      Default:
        false

  - - #### intValue

          int intValue

      Specify an integer constant to match, includes byte and short values.

      Special note for referencing `0` (zero) which forms part of a comparison expression: See the `expandZeroConditions()` option below.

      Returns:
        integer value to match
      Default:
        0

  - - #### floatValue

          float floatValue

      Specify a float constant to match
      Returns:
        float value to match
      Default:
        0.0f

  - - #### longValue

          long longValue

      Specify a long constant to match
      Returns:
        long value to match
      Default:
        0L

  - - #### doubleValue

          double doubleValue

      Specify a double constant to match
      Returns:
        double value to match
      Default:
        0.0

  - - #### stringValue

          java.lang.String stringValue

      Specify a String constant to match
      Returns:
        string value to match
      Default:
        ""

  - - #### classValue

          java.lang.Class<?> classValue

      Specify a type literal to match
      Returns:
        type literal to match
      Default:
        java.lang.Object.class

  - - #### ordinal

          int ordinal

      Ordinal offset. Many InjectionPoints will return every opcode matching their criteria, specifying ordinal allows a particular opcode to be identified from the returned list. The default value of -1 does not alter the behaviour and returns all matching opcodes. Specifying a value of 0 or higher returns only the requested opcode (if one exists: for example specifying an ordinal of 4 when only 2 opcodes are matched by the InjectionPoint is not going to work particularly well!)
      Returns:
        ordinal value for supported InjectionPoint types
      Default:
        -1

  - - #### slice

          java.lang.String slice

      This specifies the ID of the slice to use for this query.

      For more details see the `Slice.id()`

      Returns:
        the slice identifier, or empty string to use the default slice
      Default:
        ""

  - - #### expandZeroConditions

          Constant.Condition[] expandZeroConditions

      Whilst most constants can be located in the compiled method with relative ease, there exists a special case when a `zero` is used in a conditional expression. For example:

      > `if (x >= 0)`

      This special case occurs because java includes explicit instructions for this type of comparison, and thus the compiled code might look more like this:

      > `if (x.isGreaterThanOrEqualToZero())`

      Of course if we know that the constant we are searching for is part of a comparison, then we can explicitly search for the `isGreaterThanOrEqualToZero` and convert it back to the original form in order to redirect it just like any other constant access.

      To enable this behaviour, you may specify one or more values for this argument based on the type of expression you wish to expand. Since the Java compiler is wont to compile certain expressions as the inverse of their source-level counterparts (eg. compiling a do this if greater than structure to a ignore this if less than or equal structure); specifying a particular expression type implicitly includes the inverse expression as well.

      It is worth noting that the effect on ordinals may be hard to predict, and thus care should be taken to ensure that the selected injection points match the expected locations.

      Specifying this option has the following effects:

      - Matching conditional opcodes in the target method are identified for injection candidacy.
      - An `intValue` of `0` is implied and does not need to be explicitly defined.
      - However, explicitly specifying an `intValue` of `0` will cause this selector to also match explicit `0` constants in the method body as well.
      Default:
        {}

  - - #### log

          boolean log

      Returns:
        true to enable verbose debug logging for this injection point
      Default:
        false