LongRangeSet (Unofficial IntelliJ Community Edition API docs)

java.lang.Object
- com.intellij.codeInspection.dataFlow.rangeSet.LongRangeSet

```
public abstract class LongRangeSet
extends java.lang.Object
```
An immutable set of long values optimized for small number of ranges.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`abstract LongRangeSet`	`abs(boolean isLong)` Returns a range which represents all the possible values after applying `Math.abs(int)` or `Math.abs(long)` to the values from this set
`static LongRangeSet`	`all()`
`LongRangeSet`	`binOpFromToken(IElementType token, LongRangeSet right, boolean isLong)` Performs a supported binary operation from token (defined in `JavaTokenType`).
`LongRangeSet`	`bitwiseAnd(LongRangeSet other)` Returns a range which represents all the possible values after applying `x & y` operation for all `x` from this set and for all `y` from the other set.
`LongRangeSet`	`bitwiseOr(LongRangeSet other, boolean isLong)` Returns a range which represents all the possible values after applying `x \| y` operation for all `x` from this set and for all `y` from the other set.
`LongRangeSet`	`bitwiseXor(LongRangeSet other, boolean isLong)` Returns a range which represents all the possible values after applying `x ^ y` operation for all `x` from this set and for all `y` from the other set.
`abstract LongRangeSet`	`castTo(PsiPrimitiveType type)`
`abstract boolean`	`contains(long value)` Checks whether current set contains given value
`abstract boolean`	`contains(LongRangeSet other)` Checks whether current set contains all the values from other set
`LongRangeSet`	`div(LongRangeSet divisor, boolean isLong)` Returns a range which represents all the possible values after applying `x / y` operation for all `x` from this set and for all `y` from the divisor set.
`static LongRangeSet`	`empty()`
`static LongRangeSet`	`fromConstant(java.lang.Object val)` Creates a set containing single value which is equivalent to supplied boxed constant (if its type is supported)
`static LongRangeSet`	`fromPsiElement(PsiModifierListOwner owner)`
`LongRangeSet`	`fromRelation(RelationType relation)` Creates a new set which contains all possible values satisfying given predicate regarding the current set.
`static LongRangeSet`	`fromRemainder(long mod, LongRangeSet remainders)` Creates a LongRangeSet of values `x` for which `remainders.contains(x % mod)`.
`static LongRangeSet`	`fromType(PsiType type)` Creates a range for given type (for primitives and boxed: values range)
`java.lang.Long`	`getConstantValue()`
`abstract java.lang.String`	`getPresentationText(PsiType type)`
`static LongRangeSet`	`indexRange()`
`abstract LongRangeSet`	`intersect(LongRangeSet other)` Intersects current set with other
`abstract boolean`	`intersects(LongRangeSet other)` Checks if current set and other set have at least one common element
`abstract boolean`	`isCardinalityBigger(long cutoff)`
`boolean`	`isEmpty()`
`abstract long`	`max()`
`abstract long`	`min()`
`LongRangeSet`	`minus(LongRangeSet other, boolean isLong)` Returns a range which represents all the possible values after performing an addition between any value from this range and any value from other range.
`abstract LongRangeSet`	`mod(LongRangeSet divisor)` Returns a range which represents all the possible values after applying `x % y` operation for all `x` from this set and for all `y` from the divisor set.
`static LongRangeSet`	`modRange(long from, long to, long mod, long bits)` Creates a new set which contains all the numbers between from (inclusive) and to (inclusive) which are equal to any of the set bits in supplied bit-mask modulo supplied mod
`abstract LongRangeSet`	`mul(LongRangeSet multiplier, boolean isLong)`
`abstract LongRangeSet`	`negate(boolean isLong)` Returns a range which represents all the possible values after applying unary minus to the values from this set
`abstract LongRangeSet`	`plus(LongRangeSet other, boolean isLong)` Returns a range which represents all the possible values after performing an addition between any value from this range and any value from other range.
`static LongRangeSet`	`point(long value)` Creates a set containing single given value
`static LongRangeSet`	`range(long from, long to)` Creates a new set which contains all the numbers between from (inclusive) and to (inclusive)
`LongRangeSet`	`shiftLeft(LongRangeSet shiftSize, boolean isLong)` Returns a range which represents all the possible values after applying `x << y` operation for all `x` from this set and for all `y` from the shiftSize set.
`LongRangeSet`	`shiftRight(LongRangeSet shiftSize, boolean isLong)` Returns a range which represents all the possible values after applying `x >> y` operation for all `x` from this set and for all `y` from the shiftSize set.
`abstract java.util.stream.LongStream`	`stream()` Returns a stream of all values from this range.
`abstract LongRangeSet`	`subtract(LongRangeSet other)` Subtracts given set from the current
`boolean`	`subtractionMayOverflow(LongRangeSet other, boolean isLong)` Checks whether subtraction of this and other range may overflow
`abstract LongRangeSet`	`unite(LongRangeSet other)` Merge current set with other
`LongRangeSet`	`unsignedShiftRight(LongRangeSet shiftSize, boolean isLong)` Returns a range which represents all the possible values after applying `x >>> y` operation for all `x` from this set and for all `y` from the shiftSize set.
`LongRangeSet`	`wideBinOpFromToken(IElementType token, LongRangeSet other, boolean isLong)`
`LongRangeSet`	`without(long value)`

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

- Method Detail
  - subtract
```
public abstract LongRangeSet subtract(LongRangeSet other)
```
    Subtracts given set from the current
    
    Parameters:
    
    other - set to subtract
    
    Returns:
    
    a new set
  - without
```
public LongRangeSet without(long value)
```
  - isEmpty
```
public boolean isEmpty()
```
    Returns:
    
    true if set is empty
  - intersect
```
public abstract LongRangeSet intersect(LongRangeSet other)
```
    Intersects current set with other
    
    Parameters:
    
    other - other set to intersect with
    
    Returns:
    
    a new set
  - unite
```
public abstract LongRangeSet unite(LongRangeSet other)
```
    Merge current set with other
    
    Parameters:
    
    other - other set to merge with
    
    Returns:
    
    a new set
  - min
```
public abstract long min()
```
    Returns:
    
    a minimal value contained in the set
    
    Throws:
    
    java.util.NoSuchElementException - if set is empty
  - max
```
public abstract long max()
```
    Returns:
    
    a maximal value contained in the set
    
    Throws:
    
    java.util.NoSuchElementException - if set is empty
  - getConstantValue
```
public java.lang.Long getConstantValue()
```
    Returns:
    
    a constant value if this set represents a constant; null otherwise
  - intersects
```
public abstract boolean intersects(LongRangeSet other)
```
    Checks if current set and other set have at least one common element
    
    Parameters:
    
    other - other set to check whether intersection exists
    
    Returns:
    
    true if this set intersects other set
  - contains
```
public abstract boolean contains(long value)
```
    Checks whether current set contains given value
    
    Parameters:
    
    value - value to find
    
    Returns:
    
    true if current set contains given value
  - contains
```
public abstract boolean contains(LongRangeSet other)
```
    Checks whether current set contains all the values from other set
    
    Parameters:
    
    other - a sub-set candidate
    
    Returns:
    
    true if current set contains all the values from other
  - fromRelation
```
public LongRangeSet fromRelation(RelationType relation)
```
    Creates a new set which contains all possible values satisfying given predicate regarding the current set.
    E.g. if current set is {0..10} and relation is "GT", then result will be {1..Long.MAX_VALUE} (values which can be greater than some value from the current set)
    
    Parameters:
    
    relation - relation to be applied to current set (JavaTokenType.EQEQ/NE/GT/GE/LT/LE)
    
    Returns:
    
    new set or null if relation is unsupported
  - getPresentationText
```
public abstract java.lang.String getPresentationText(PsiType type)
```
  - binOpFromToken
```
public final LongRangeSet binOpFromToken(IElementType token,
                                         LongRangeSet right,
                                         boolean isLong)
```
    Performs a supported binary operation from token (defined in JavaTokenType).
    
    Parameters:
    
    token - a token which corresponds to the operation
    
    right - a right-hand operand
    
    isLong - true if operation should be performed on long types (otherwise int is assumed)
    
    Returns:
    
    the resulting LongRangeSet which covers possible results of the operation (probably including some more elements); or null if the supplied token is not supported.
  - wideBinOpFromToken
```
public LongRangeSet wideBinOpFromToken(IElementType token,
                                       LongRangeSet other,
                                       boolean isLong)
```
  - isCardinalityBigger
```
public abstract boolean isCardinalityBigger(long cutoff)
```
  - castTo
```
public abstract LongRangeSet castTo(PsiPrimitiveType type)
```
  - abs
```
public abstract LongRangeSet abs(boolean isLong)
```
    Returns a range which represents all the possible values after applying Math.abs(int) or Math.abs(long) to the values from this set
    
    Parameters:
    
    isLong - whether Math.abs(long) is applied
    
    Returns:
    
    a new range
  - negate
```
public abstract LongRangeSet negate(boolean isLong)
```
    Returns a range which represents all the possible values after applying unary minus to the values from this set
    
    Parameters:
    
    isLong - whether result should be truncated to int
    
    Returns:
    
    a new range
  - plus
```
public abstract LongRangeSet plus(LongRangeSet other,
                                  boolean isLong)
```
    Returns a range which represents all the possible values after performing an addition between any value from this range and any value from other range. The resulting range may contain some more values which cannot be produced by addition. Guaranteed to be commutative.
    
    Parameters:
    
    isLong - whether result should be truncated to int
    
    Returns:
    
    a new range
  - minus
```
public LongRangeSet minus(LongRangeSet other,
                          boolean isLong)
```
    Returns a range which represents all the possible values after performing an addition between any value from this range and any value from other range. The resulting range may contain some more values which cannot be produced by addition.
    
    Parameters:
    
    isLong - whether result should be truncated to int
    
    Returns:
    
    a new range
  - bitwiseOr
```
public LongRangeSet bitwiseOr(LongRangeSet other,
                              boolean isLong)
```
    Returns a range which represents all the possible values after applying x | y operation for all x from this set and for all y from the other set. The resulting set may contain some more values.
    
    Parameters:
    
    other - other set to perform bitwise-or with
    
    Returns:
    
    a new range
  - bitwiseXor
```
public LongRangeSet bitwiseXor(LongRangeSet other,
                               boolean isLong)
```
    Returns a range which represents all the possible values after applying x ^ y operation for all x from this set and for all y from the other set. The resulting set may contain some more values.
    
    Parameters:
    
    other - other set to perform bitwise-xor with
    
    Returns:
    
    a new range
  - bitwiseAnd
```
public LongRangeSet bitwiseAnd(LongRangeSet other)
```
    Returns a range which represents all the possible values after applying x & y operation for all x from this set and for all y from the other set. The resulting set may contain some more values.
    
    Parameters:
    
    other - other set to perform bitwise-and with
    
    Returns:
    
    a new range
  - mul
```
public abstract LongRangeSet mul(LongRangeSet multiplier,
                                 boolean isLong)
```
  - div
```
public LongRangeSet div(LongRangeSet divisor,
                        boolean isLong)
```
    Returns a range which represents all the possible values after applying x / y operation for all x from this set and for all y from the divisor set. The resulting set may contain some more values. Division by zero yields an empty set of possible results.
    
    Parameters:
    
    divisor - divisor set to divide by
    
    isLong - whether the operation is performed on long type (if false, the int type is assumed). This only changes the special treatment of MIN_VALUE/-1 division; other division results do not depend on the resulting type.
    
    Returns:
    
    a new range
  - subtractionMayOverflow
```
public boolean subtractionMayOverflow(LongRangeSet other,
                                      boolean isLong)
```
    Checks whether subtraction of this and other range may overflow
    
    Parameters:
    
    other - range to subtract from this range
    
    isLong - whether subtraction should be performed on long values (otherwise int is assumed)
    
    Returns:
    
    true if result may overflow, false if it never overflows
  - shiftLeft
```
public LongRangeSet shiftLeft(LongRangeSet shiftSize,
                              boolean isLong)
```
    Returns a range which represents all the possible values after applying x << y operation for all x from this set and for all y from the shiftSize set. The resulting set may contain some more values.
    
    Parameters:
    
    shiftSize - set of possible shift sizes (number of bits to shift to the left)
    
    isLong - whether the operation is performed on long type (if false, the int type is assumed).
    
    Returns:
    
    a new range
  - shiftRight
```
public LongRangeSet shiftRight(LongRangeSet shiftSize,
                               boolean isLong)
```
    Returns a range which represents all the possible values after applying x >> y operation for all x from this set and for all y from the shiftSize set. The resulting set may contain some more values.
    
    Parameters:
    
    shiftSize - set of possible shift sizes (number of bits to shift to the right)
    
    isLong - whether the operation is performed on long type (if false, the int type is assumed).
    
    Returns:
    
    a new range
  - unsignedShiftRight
```
public LongRangeSet unsignedShiftRight(LongRangeSet shiftSize,
                                       boolean isLong)
```
    Returns a range which represents all the possible values after applying x >>> y operation for all x from this set and for all y from the shiftSize set. The resulting set may contain some more values.
    
    Parameters:
    
    shiftSize - set of possible shift sizes (number of bits to shift to the right)
    
    isLong - whether the operation is performed on long type (if false, the int type is assumed).
    
    Returns:
    
    a new range
  - mod
```
public abstract LongRangeSet mod(LongRangeSet divisor)
```
    Returns a range which represents all the possible values after applying x % y operation for all x from this set and for all y from the divisor set. The resulting set may contain some more values. Division by zero yields an empty set of possible results.
    
    Parameters:
    
    divisor - divisor set to divide by
    
    Returns:
    
    a new range
  - stream
```
public abstract java.util.stream.LongStream stream()
```
    Returns a stream of all values from this range. Be careful: could be huge
    
    Returns:
    
    a new stream
  - empty
```
public static LongRangeSet empty()
```
    Returns:
    
    an empty set
  - all
```
public static LongRangeSet all()
```
    Returns:
    
    a set containing all possible long values
  - point
```
public static LongRangeSet point(long value)
```
    Creates a set containing single given value
    
    Parameters:
    
    value - a value to be included into the set
    
    Returns:
    
    a new set
  - fromConstant
```
public static LongRangeSet fromConstant(java.lang.Object val)
```
    Creates a set containing single value which is equivalent to supplied boxed constant (if its type is supported)
    
    Parameters:
    
    val - constant to create a set from
    
    Returns:
    
    new LongRangeSet or null if constant type is unsupported
  - range
```
public static LongRangeSet range(long from,
                                 long to)
```
    Creates a new set which contains all the numbers between from (inclusive) and to (inclusive)
    
    Parameters:
    
    from - lower bound
    
    to - upper bound (must be greater or equal to from)
    
    Returns:
    
    a new LongRangeSet
  - modRange
```
public static LongRangeSet modRange(long from,
                                    long to,
                                    long mod,
                                    long bits)
```
    Creates a new set which contains all the numbers between from (inclusive) and to (inclusive) which are equal to any of the set bits in supplied bit-mask modulo supplied mod
    
    Parameters:
    
    from - lower bound
    
    to - upper bound (must be greater or equal to from)
    
    mod - modulus; only modulus up to 64 is supported; bigger modulus is not tracked (instead full range will be returned)
    
    bits - a bit-mask which represents allowed remainders: 0b1 represents that only (x % mod == 0) numbers are included; 0b10 represents that only (x % mod == 1) numbers are included and so on.
    
    Returns:
    
    a new LongRangeSet
  - indexRange
```
public static LongRangeSet indexRange()
```
    Returns:
    
    LongRangeSet describing possible array or string indices (from 0 to Integer.MAX_VALUE)
  - fromType
```
public static LongRangeSet fromType(PsiType type)
```
    Creates a range for given type (for primitives and boxed: values range)
    
    Parameters:
    
    type - type to create a range for
    
    Returns:
    
    a range or null if type is not supported
  - fromPsiElement
```
public static LongRangeSet fromPsiElement(PsiModifierListOwner owner)
```
  - fromRemainder
```
public static LongRangeSet fromRemainder(long mod,
                                         LongRangeSet remainders)
```
    Creates a LongRangeSet of values x for which remainders.contains(x % mod). May include more values as well.
    
    Parameters:
    
    mod - a divisor
    
    remainders - set of allowed remainders
    
    Returns:
    
    set of values which may produce supplied remainders when divided by mod.

Class LongRangeSet

Method Summary

Methods inherited from class java.lang.Object

Method Detail

subtract

without

isEmpty

intersect

unite

min

max

getConstantValue

intersects

contains

contains

fromRelation

getPresentationText

binOpFromToken

wideBinOpFromToken

isCardinalityBigger

castTo

abs

negate

plus

minus

bitwiseOr

bitwiseXor

bitwiseAnd

mul

div

subtractionMayOverflow

shiftLeft

shiftRight

unsignedShiftRight

mod

stream

empty

all

point

fromConstant

range

modRange

indexRange

fromType

fromPsiElement

fromRemainder