WideningCategories (Groovy 2.4.13)

java.lang.Object
- org.codehaus.groovy.ast.tools.WideningCategories

```
public class WideningCategories
extends java.lang.Object
```
This class provides helper methods to determine the type from a widening operation for example for a plus operation.
To determine the resulting type of for example a=exp1+exp2 we look at the conditions isIntCategory(ClassNode), isLongCategory(ClassNode), isBigIntCategory(ClassNode), isDoubleCategory(ClassNode) and isBigDecCategory(ClassNode) in that order. The first case applying to exp1 and exp2 is defining the result type of the expression.
If for example you look at x = 1 + 2l we have the first category applying to the number 1 being int, since the 1 is an int. The 2l is a long, therefore the int category will not apply and the result type can't be int. The next category in the list is long, and since both apply to long, the result type is a long.

Author:

Jochen "blackdrag" Theodorou, Cedric Champeau

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`WideningCategories.LowestUpperBoundClassNode` This `ClassNode` specialization is used when the lowest upper bound of two types cannot be represented by an existing type.

Constructor Summary

Constructors
Constructor and Description

WideningCategories()

Constructors
Constructor and Description
`WideningCategories()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean`	`implementsInterfaceOrSubclassOf(ClassNode source, ClassNode targetType)` Determines if the source class implements an interface or subclasses the target type.
`static boolean`	`isBigDecCategory(ClassNode type)` It is of a BigDecimal category, if the provided type is a BigInteger category or a BigDecimal.
`static boolean`	`isBigIntCategory(ClassNode type)` It is of a BigInteger category, if the provided type is a long category or a BigInteger.
`static boolean`	`isDouble(ClassNode type)` Used to check if a type is an double or Double.
`static boolean`	`isDoubleCategory(ClassNode type)` It is of a double category, if the provided type is a BigDecimal, a float, double.
`static boolean`	`isFloat(ClassNode type)` Used to check if a type is a float or Float.
`static boolean`	`isFloatingCategory(ClassNode type)` It is of a floating category, if the provided type is a a float, double.
`static boolean`	`isInt(ClassNode type)` Used to check if a type is an int or Integer.
`static boolean`	`isIntCategory(ClassNode type)` It is of an int category, if the provided type is a byte, char, short, int.
`static boolean`	`isLongCategory(ClassNode type)` It is of a long category, if the provided type is a long, its wrapper or if it is a long category.
`static boolean`	`isNumberCategory(ClassNode type)`
`static ClassNode`	`lowestUpperBound(ClassNode a, ClassNode b)` Given two class nodes, returns the first common supertype, or the class itself if there are equal.
`static ClassNode`	`lowestUpperBound(java.util.List<ClassNode> nodes)` Given a list of class nodes, returns the first common supertype.

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

- Constructor Detail
  - WideningCategories
```
public WideningCategories()
```
- Method Detail
  - isInt
```
public static boolean isInt(ClassNode type)
```
    Used to check if a type is an int or Integer.
    
    Parameters:
    
    type - the type to check
  - isDouble
```
public static boolean isDouble(ClassNode type)
```
    Used to check if a type is an double or Double.
    
    Parameters:
    
    type - the type to check
  - isFloat
```
public static boolean isFloat(ClassNode type)
```
    Used to check if a type is a float or Float.
    
    Parameters:
    
    type - the type to check
  - isIntCategory
```
public static boolean isIntCategory(ClassNode type)
```
    It is of an int category, if the provided type is a byte, char, short, int.
  - isLongCategory
```
public static boolean isLongCategory(ClassNode type)
```
    It is of a long category, if the provided type is a long, its wrapper or if it is a long category.
  - isBigIntCategory
```
public static boolean isBigIntCategory(ClassNode type)
```
    It is of a BigInteger category, if the provided type is a long category or a BigInteger.
  - isBigDecCategory
```
public static boolean isBigDecCategory(ClassNode type)
```
    It is of a BigDecimal category, if the provided type is a BigInteger category or a BigDecimal.
  - isDoubleCategory
```
public static boolean isDoubleCategory(ClassNode type)
```
    It is of a double category, if the provided type is a BigDecimal, a float, double. C(type)=double
  - isFloatingCategory
```
public static boolean isFloatingCategory(ClassNode type)
```
    It is of a floating category, if the provided type is a a float, double. C(type)=float
  - isNumberCategory
```
public static boolean isNumberCategory(ClassNode type)
```
  - lowestUpperBound
```
public static ClassNode lowestUpperBound(java.util.List<ClassNode> nodes)
```
    Given a list of class nodes, returns the first common supertype. For example, Double and Float would return Number, while Set and String would return Object.
    
    Parameters:
    
    nodes - the list of nodes for which to find the first common super type.
    
    Returns:
    
    first common supertype
  - lowestUpperBound
```
public static ClassNode lowestUpperBound(ClassNode a,
                                         ClassNode b)
```
    Given two class nodes, returns the first common supertype, or the class itself if there are equal. For example, Double and Float would return Number, while Set and String would return Object. This method is not guaranteed to return a class node which corresponds to a real type. For example, if two types have more than one interface in common and are not in the same hierarchy branch, then the returned type will be a virtual type implementing all those interfaces. Calls to this method are supposed to be made with resolved generics. This means that you can have wildcards, but no placeholder.
    
    Parameters:
    
    a - first class node
    
    b - second class node
    
    Returns:
    
    first common supertype
  - implementsInterfaceOrSubclassOf
```
public static boolean implementsInterfaceOrSubclassOf(ClassNode source,
                                                      ClassNode targetType)
```
    Determines if the source class implements an interface or subclasses the target type. This method takes the lowest upper bound class node type into account, allowing to remove unnecessary casts.
    
    Parameters:
    
    source - the type of interest
    
    targetType - the target type of interest

Class WideningCategories

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

WideningCategories

Method Detail

isInt

isDouble

isFloat

isIntCategory

isLongCategory

isBigIntCategory

isBigDecCategory

isDoubleCategory

isFloatingCategory

isNumberCategory

lowestUpperBound

lowestUpperBound

implementsInterfaceOrSubclassOf