org.hibernate.validator.constraints

## Annotation Type Mod11Check

-     @Documented
      @Constraint(validatedBy={})
      @Target(value={METHOD,FIELD,ANNOTATION_TYPE,CONSTRUCTOR,PARAMETER})
      @Retention(value=RUNTIME)
      public @interface Mod11Check

  Modulo 11 check constraint.

  Allows to validate that a series of digits passes the Mod11 checksum algorithm. For the most common Mod11 variant the sum calculation is done by multiplying a weight from the rightmost digit (excluding the check digit) to the leftmost. The weight starts with 2 and increases by 1 for each digit. Then the result is used to calculate the check digit using `11 - ( sum % 11 )`.

  Example: The check digit for 24187 is 3
  Sum = 7x2 + 8x3 + 1x4 + 4x5 + 2x6 = 74
  11 - (74 % 11) = 11 - 8 = 3, so "24187-3" is a valid character sequence.

  The Mod11 calculation can result in 10 or 11; per default 10 is treated as `'X'` and 11 as `'0'`, this behavior can be changed using the options `treatCheck10As` and `treatCheck10As`.

  Some implementations do the sum calculation in the reverse order (left to right); specify the processing direction `Mod11Check.ProcessingDirection.LEFT_TO_RIGHT` in this case.

  The supported type is `CharSequence`. `null` is considered valid.

  Author:
    George Gastaldi, Hardy Ferentschik, Victor Rezende dos Santos

- - ### Optional Element Summary

    Optional Elements
    Modifier and Type | Optional Element and Description
    --- | ---
    `int` | `checkDigitIndex`
    `int` | `endIndex`
    `Class<?>[]` | `groups`
    `boolean` | `ignoreNonDigitCharacters`
    `String` | `message`
    `Class<? extends Payload>[]` | `payload`
    `Mod11Check.ProcessingDirection` | `processingDirection`
    `int` | `startIndex`
    `int` | `threshold`
    `char` | `treatCheck10As`
    `char` | `treatCheck11As`

- - ### Element Detail

    - #### message

          public abstract String message

      Default:
        "{org.hibernate.validator.constraints.Mod11Check.message}"

    - #### groups

          public abstract Class<?>[] groups

      Default:
        {}

    - #### payload

          public abstract Class<? extends Payload>[] payload

      Default:
        {}

    - #### threshold

          public abstract int threshold

      Returns:
        The threshold for the Mod11 algorithm multiplier growth, if no value is specified the multiplier will grow indefinitely
      Default:
        2147483647

    - #### startIndex

          public abstract int startIndex

      Returns:
        the start index (inclusive) for calculating the checksum. If not specified 0 is assumed.
      Default:
        0

    - #### endIndex

          public abstract int endIndex

      Returns:
        the end index (inclusive) for calculating the checksum. If not specified the whole value is considered
      Default:
        2147483647

    - #### checkDigitIndex

          public abstract int checkDigitIndex

      Returns:
        The index of the check digit in the input. Per default it is assumed that the check digit is the last digit of the specified range. If set, the digit at the specified index is used. If set the following must hold true:
        `checkDigitIndex > 0 && (checkDigitIndex < startIndex || checkDigitIndex >= endIndex`.
      Default:
        -1

    - #### ignoreNonDigitCharacters

          public abstract boolean ignoreNonDigitCharacters

      Returns:
        Whether non-digit characters in the validated input should be ignored (`true`) or result in a validation error (`false`).
      Default:
        false

    - #### treatCheck10As

          public abstract char treatCheck10As

      Returns:
        The `char` that represents the check digit when the Mod11 checksum equals 10. If not specified `'X'` is assumed.
      Default:
        88

    - #### treatCheck11As

          public abstract char treatCheck11As

      Returns:
        The `char` that represents the check digit when the Mod11 checksum equals 11. If not specified `'0'` is assumed.
      Default:
        48

    - #### processingDirection

          public abstract Mod11Check.ProcessingDirection processingDirection

      Returns:
        Returns `RIGHT_TO_LEFT` if the Mod11 checksum must be done from the rightmost to the leftmost digit. e.g. Code 12345-?:
        - `RIGHT_TO_LEFT` the sum (5*2 + 4*3 + 3*4 + 2*5 + 1*6) with check digit 5
        - `LEFT_TO_RIGHT` the sum (1*2 + 2*3 + 3*4 + 4*5 + 5*6) with check digit 7
        If not specified `RIGHT_TO_LEFT` is assumed, it is the default Mod11 behavior.
      Default:
        org.hibernate.validator.constraints.Mod11Check.ProcessingDirection.RIGHT_TO_LEFT

Copyright © 2007-2014 Red Hat, Inc. All Rights Reserved