StandardSyntaxRules (sellcom-java 1.1.0)

java.lang.Object
- org.sellcom.core.security.password.StandardSyntaxRules

public class StandardSyntaxRules
extends Object

Standard syntax rules.

Since:: 1.0

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static ToDoubleFunction<char[]>`	`characterClasses(int minClasses, double weight)` Returns a syntax rule scoring the number of character classes in the password.
`static ToDoubleFunction<char[]>`	`consecutiveDigits(double weight)` Returns a syntax rule scoring the number of consecutive digits in the password.
`static ToDoubleFunction<char[]>`	`consecutiveLowerCaseLetters(double weight)` Returns a syntax rule scoring the number of consecutive lower-case letters in the password.
`static ToDoubleFunction<char[]>`	`consecutiveUpperCaseLetters(double weight)` Returns a syntax rule scoring the number of consecutive upper-case letters in the password.
`static ToDoubleFunction<char[]>`	`digits(double weight)` Returns a syntax rule scoring the number of digits in the password.
`static ToDoubleFunction<char[]>`	`digitsOnly(double weight)` Returns a syntax rule scoring digit-only passwords.
`static ToDoubleFunction<char[]>`	`length(int minLength, double weight)` Returns a syntax rule scoring the length of the password.
`static ToDoubleFunction<char[]>`	`lessCommonSpecialChars(double weight)` Returns a syntax rule scoring the number of less common special characters in the password.
`static ToDoubleFunction<char[]>`	`lettersOnly(double weight)` Returns a syntax rule scoring letter-only passwords.
`static ToDoubleFunction<char[]>`	`lowerCaseLetters(double weight)` Returns a syntax rule scoring the number of lower-case letters in the password.
`static ToDoubleFunction<char[]>`	`midDigits(double weight)` Returns a syntax rule scoring the number of digits in the middle of the password.
`static ToDoubleFunction<char[]>`	`midLessCommonSpecialChars(double weight)` Returns a syntax rule scoring the number of less common special characters in the middle of the password.
`static ToDoubleFunction<char[]>`	`midMoreCommonSpecialChars(double weight)` Returns a syntax rule scoring the number of more common special characters in the middle of the password.
`static ToDoubleFunction<char[]>`	`moreCommonSpecialChars(double weight)` Returns a syntax rule scoring the number of more common special characters in the password.
`static ToDoubleFunction<char[]>`	`sequentialDigits(int minSequenceLength, double weight)` Returns a syntax rule scoring the sequences of digits in the password.
`static ToDoubleFunction<char[]>`	`sequentialLetters(int minSequenceLength, double weight)` Returns a syntax rule scoring the sequences of letters in the password.
`static ToDoubleFunction<char[]>`	`sequentialSpecialChars(int minSequenceLength, double weight)` Returns a syntax rule scoring the sequences of special characters in the password.
`static ToDoubleFunction<char[]>`	`upperCaseLetters(double weight)` Returns a syntax rule scoring the number of upper-case letters in the password.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - characterClasses
```
public static ToDoubleFunction<char[]> characterClasses(int minClasses,
                                                        double weight)
```
    Returns a syntax rule scoring the number of character classes in the password.
    
    Throws:
    
    IllegalArgumentException - if minClasses is not positive
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - consecutiveDigits
```
public static ToDoubleFunction<char[]> consecutiveDigits(double weight)
```
    Returns a syntax rule scoring the number of consecutive digits in the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - consecutiveLowerCaseLetters
```
public static ToDoubleFunction<char[]> consecutiveLowerCaseLetters(double weight)
```
    Returns a syntax rule scoring the number of consecutive lower-case letters in the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - consecutiveUpperCaseLetters
```
public static ToDoubleFunction<char[]> consecutiveUpperCaseLetters(double weight)
```
    Returns a syntax rule scoring the number of consecutive upper-case letters in the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - digits
```
public static ToDoubleFunction<char[]> digits(double weight)
```
    Returns a syntax rule scoring the number of digits in the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - digitsOnly
```
public static ToDoubleFunction<char[]> digitsOnly(double weight)
```
    Returns a syntax rule scoring digit-only passwords.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - length
```
public static ToDoubleFunction<char[]> length(int minLength,
                                              double weight)
```
    Returns a syntax rule scoring the length of the password.
    
    Throws:
    
    IllegalArgumentException - if minLength is not positive
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - lessCommonSpecialChars
```
public static ToDoubleFunction<char[]> lessCommonSpecialChars(double weight)
```
    Returns a syntax rule scoring the number of less common special characters in the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - lettersOnly
```
public static ToDoubleFunction<char[]> lettersOnly(double weight)
```
    Returns a syntax rule scoring letter-only passwords.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - lowerCaseLetters
```
public static ToDoubleFunction<char[]> lowerCaseLetters(double weight)
```
    Returns a syntax rule scoring the number of lower-case letters in the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - midDigits
```
public static ToDoubleFunction<char[]> midDigits(double weight)
```
    Returns a syntax rule scoring the number of digits in the middle of the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - midLessCommonSpecialChars
```
public static ToDoubleFunction<char[]> midLessCommonSpecialChars(double weight)
```
    Returns a syntax rule scoring the number of less common special characters in the middle of the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - midMoreCommonSpecialChars
```
public static ToDoubleFunction<char[]> midMoreCommonSpecialChars(double weight)
```
    Returns a syntax rule scoring the number of more common special characters in the middle of the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - moreCommonSpecialChars
```
public static ToDoubleFunction<char[]> moreCommonSpecialChars(double weight)
```
    Returns a syntax rule scoring the number of more common special characters in the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - sequentialDigits
```
public static ToDoubleFunction<char[]> sequentialDigits(int minSequenceLength,
                                                        double weight)
```
    Returns a syntax rule scoring the sequences of digits in the password.
    
    Throws:
    
    IllegalArgumentException - if minSequenceLength is less than 2
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - sequentialLetters
```
public static ToDoubleFunction<char[]> sequentialLetters(int minSequenceLength,
                                                         double weight)
```
    Returns a syntax rule scoring the sequences of letters in the password.
    
    Throws:
    
    IllegalArgumentException - if minSequenceLength is less than 2
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - sequentialSpecialChars
```
public static ToDoubleFunction<char[]> sequentialSpecialChars(int minSequenceLength,
                                                              double weight)
```
    Returns a syntax rule scoring the sequences of special characters in the password.
    
    Throws:
    
    IllegalArgumentException - if minSequenceLength is less than 2
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0
  - upperCaseLetters
```
public static ToDoubleFunction<char[]> upperCaseLetters(double weight)
```
    Returns a syntax rule scoring the number of upper-case letters in the password.
    
    Throws:
    
    IllegalArgumentException - if weight is not a finite value
    
    Since:
    
    1.0

Class StandardSyntaxRules

Method Summary

Methods inherited from class java.lang.Object

Method Detail

characterClasses

consecutiveDigits

consecutiveLowerCaseLetters

consecutiveUpperCaseLetters

digits

digitsOnly

length

lessCommonSpecialChars

lettersOnly

lowerCaseLetters

midDigits

midLessCommonSpecialChars

midMoreCommonSpecialChars

moreCommonSpecialChars

sequentialDigits

sequentialLetters

sequentialSpecialChars

upperCaseLetters