JavaUtil (Schema2beans repackaged as an OSGI bundle 6.6 API)

java.lang.Object
- org.netbeans.modules.schema2beansdev.gen.JavaUtil

```
public class JavaUtil
extends Object
```
Various utility methods dealing with Java

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class JavaUtil.InputMonitor

static class JavaUtil.N2AFilter

Nested Classes
Modifier and Type	Class and Description
`static class`	`JavaUtil.InputMonitor`
`static class`	`JavaUtil.N2AFilter`

Field Summary

Fields
Modifier and Type Field and Description

static int BUFFER_SIZE

Fields
Modifier and Type	Field and Description
`static int`	`BUFFER_SIZE`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static String`	`baseClassOfArray(String className)`
`static String`	`baseName(String fullClassName)` This will return a name from @param fullClassName where everything upto and including the last '.' is removed.
`static boolean`	`canProduceNoXMLMetaChars(String className)`
`static boolean`	`checkValueToType(String type, String value)` checkValueToType will make sure that a given value is acceptable for a given type.
`static String`	`compareTo(String value1, String type1, String value2)` Convert @param value2 (a literal) to @param type1 and then compare that to @param value1.
`static String`	`compareToText(String value1, String type1, String value2Text)` Just like compareTo, but the second value (@param value2Text) is unquoted text.
`static int`	`copyStream(OutputStream out, InputStream in)` copyStream is not really a Java Utility method, but it's needed by one of them, and so is here.
`static int`	`copyStream(Writer out, Reader in)` copyStream is not really a Java Utility method, but it's needed by one of them, and so is here.
`static String`	`escapeCharForInstance(char c, char illegalChar)` A helper method for instanceFrom.
`static List`	`exceptionsFromParsingText(String type)` What exceptions might we encounter from doing the result of genParseText.
`static List`	`exceptionsFromParsingText(String type, boolean fromParsing)`
`static String`	`exprToInt(String type, String expr)` Given a scalar type, figure out how to make it into an int (ie, hash code).
`static String`	`fromObject(String type, String expr)`
`static String`	`fromObjectType(String classType)` Take a Java boxed object (like Integer) and return it's primitive type.
`static String`	`genEquals(String type, String attr1, String attr2)`
`static String`	`genEquals(String type, String attr1, String attr2, boolean attr1CanBeNull)`
`static String`	`genNewDefault(String type)`
`static String`	`genParseText(String type, String expr, boolean java5)` Take a particular @param type (eg: "java.lang.Integer") and return a String that will parse the @param expr and make it into that type.
`static String`	`genParseText(String type, String expr, boolean j2me, boolean java5)`
`static String`	`genParseText(String type, String expr, String var, boolean java5)` Take a particular @param type (eg: "java.lang.Integer") and return a String that will parse the @param expr, making it into that type, and storing the value into @param var.
`static String`	`genParseText(String type, String expr, String var, boolean j2me, boolean java5)`
`static String`	`genParseTextME(String type, String name)` Take a particular @param type (eg: "java.lang.Integer") and return a String that will parse the @param expr and make it into that type.
`static String`	`getCanonicalClassName(Class cls)`
`static int`	`getOptimialHashMapSize(Object[] keys)`
`static int`	`getOptimialHashMapSize(Object[] keys, int maxSize)` Using reflection figure out the optimal initial capacity for a HashMap given some keys.
`static Class`	`getPrimitive(String className)`
`static String`	`instanceFrom(String type, String value)` Take a String (@param value) and generate Java code to coerce it.
`static boolean`	`isCloneable(String className)` Looks for the class and sees if it's cloneable.
`static boolean`	`isImmutable(String className)` Is @param className immutable? An immutable object can hold state, but after it's been constructed that state cannot change.
`static boolean`	`isInstantiable(String className)` Is the class not an interface and not abstract; i.e., it's possible to call a constructor on this class.
`static boolean`	`isPrimitiveType(String className)`
`static void`	`native2ascii(Writer out, Reader in)`
`static String`	`nullValueForType(String type)`
`static boolean`	`reservedWord(String name)`
`static String`	`toObject(String expr, String classType, boolean j2me, boolean java5)`
`static String`	`toObjectType(String classType)` Take a Java primitive and return it's object type.
`static String`	`typeToString(String type, String expr)` Convert expr into a String.
`static String`	`uencode(char c)` Take a character and return the \ u (Unicode) representation of it.

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

- Field Detail
  - BUFFER_SIZE
```
public static final int BUFFER_SIZE
```
    See Also:
    
    Constant Field Values
- Method Detail
  - toObject
```
public static String toObject(String expr,
                              String classType,
                              boolean j2me,
                              boolean java5)
```
  - toObjectType
```
public static String toObjectType(String classType)
```
    Take a Java primitive and return it's object type. Return the same type if there isn't an object version.
  - fromObjectType
```
public static String fromObjectType(String classType)
```
    Take a Java boxed object (like Integer) and return it's primitive type. Return the same type if there isn't a primitive version.
  - typeToString
```
public static String typeToString(String type,
                                  String expr)
```
    Convert expr into a String. Similar to toObject.
    
    Parameters:
    
    expr - the value to convert into a String
    
    type - is the name of the current type ('String', 'value') -> 'value' ('int', '42') -> '""+42' ('Integer', 'age') -> 'age.toString()'
  - fromObject
```
public static String fromObject(String type,
                                String expr)
```
    Parameters:
    
    expr - is an Object type, and we will convert it to a primitive. eg: ('java.lang.Double', expr) -> '(java.lang.Double) expr' eg: ('int', 'obj') -> '((java.lang.Integer)obj).intValue()'
  - isImmutable
```
public static boolean isImmutable(String className)
```
    Is @param className immutable? An immutable object can hold state, but after it's been constructed that state cannot change.
  - instanceFrom
```
public static String instanceFrom(String type,
                                  String value)
```
    Take a String (@param value) and generate Java code to coerce it. eg: ('String', "Hello") -> '"Hello"' ('int', '10') -> '10' ('Integer', '43') -> 'new Integer(43)' ('java.util.Locale', 'Locale.US') -> 'Locale.US'
  - escapeCharForInstance
```
public static String escapeCharForInstance(char c,
                                           char illegalChar)
```
    A helper method for instanceFrom. We escape 1 char at a time here.
  - compareTo
```
public static String compareTo(String value1,
                               String type1,
                               String value2)
```
    Convert @param value2 (a literal) to @param type1 and then compare that to @param value1.
    
    Returns:
    
    Java code in a String, that returns negative, 0, or positive if value1 < value2, value1 == value2, or value1 > value2. ("foo", "java.math.BigDecimal", "1") -> 'foo.compareTo(new java.math.BigDecimal("1"))'
  - compareToText
```
public static String compareToText(String value1,
                                   String type1,
                                   String value2Text)
```
    Just like compareTo, but the second value (@param value2Text) is unquoted text.
  - genParseText
```
public static String genParseText(String type,
                                  String expr,
                                  boolean j2me,
                                  boolean java5)
```
  - genParseText
```
public static String genParseText(String type,
                                  String expr,
                                  boolean java5)
```
    Take a particular @param type (eg: "java.lang.Integer") and return a String that will parse the @param expr and make it into that type. The value of @param expr should be a String. eg: ('java.lang.Integer', 'node.getNodeValue()') -> 'new java.lang.Integer(node.getNodeValue())'
  - genParseTextME
```
public static String genParseTextME(String type,
                                    String name)
```
    Take a particular @param type (eg: "java.lang.Integer") and return a String that will parse the @param expr and make it into that type. The value of @param expr should be a String. These work in *MIDP/J2ME*. eg: ('java.lang.Integer', 'node.getNodeValue()') -> 'new java.lang.Integer(node.getNodeValue())'
  - genParseText
```
public static String genParseText(String type,
                                  String expr,
                                  String var,
                                  boolean java5)
```
    Take a particular @param type (eg: "java.lang.Integer") and return a String that will parse the @param expr, making it into that type, and storing the value into @param var. The value of @param expr should be a String.
  - genParseText
```
public static String genParseText(String type,
                                  String expr,
                                  String var,
                                  boolean j2me,
                                  boolean java5)
```
  - exceptionsFromParsingText
```
public static List exceptionsFromParsingText(String type)
```
    What exceptions might we encounter from doing the result of genParseText. These exceptions are ones that we'd have to declare.
  - exceptionsFromParsingText
```
public static List exceptionsFromParsingText(String type,
                                             boolean fromParsing)
```
  - isPrimitiveType
```
public static boolean isPrimitiveType(String className)
```
  - getPrimitive
```
public static Class getPrimitive(String className)
```
  - canProduceNoXMLMetaChars
```
public static boolean canProduceNoXMLMetaChars(String className)
```
  - nullValueForType
```
public static String nullValueForType(String type)
```
  - genNewDefault
```
public static String genNewDefault(String type)
```
    Parameters:
    
    type - is the name of a class
    
    Returns:
    
    a default value for that type. eg: X -> new X() java.math.BigDecimal -> new java.math.BigDecimal("0") Integer -> new Integer("0")
  - exprToInt
```
public static String exprToInt(String type,
                               String expr)
```
    Given a scalar type, figure out how to make it into an int (ie, hash code).
  - genEquals
```
public static String genEquals(String type,
                               String attr1,
                               String attr2)
```
    Returns:
    
    an expression to compare to expressions; this can be put right into an if statement. ('int', 'var1', 'var2') -> 'var1 == var2' ('String', 'word', '"hello"') -> 'word == null ? "hello" == null : word.equals("hello")' ('float', 'var1', 'var2') -> 'Float.floatToIntBits(var1) == Float.floatToIntBits(var2)'
  - genEquals
```
public static String genEquals(String type,
                               String attr1,
                               String attr2,
                               boolean attr1CanBeNull)
```
    Parameters:
    
    attr1CanBeNull - whether or not attr1 could be null.
  - isCloneable
```
public static boolean isCloneable(String className)
```
    Looks for the class and sees if it's cloneable.
  - isInstantiable
```
public static boolean isInstantiable(String className)
```
    Is the class not an interface and not abstract; i.e., it's possible to call a constructor on this class. (Note that primitives fail.)
  - checkValueToType
```
public static boolean checkValueToType(String type,
                                       String value)
```
    checkValueToType will make sure that a given value is acceptable for a given type. To make the problem more tractable, this is limited to simple types. eg: ("java.lang.Integer", "1") -> true ("java.lang.Integer", "1.5") -> false ("java.lang.String", "ksadjflkjas24#@") -> true ("short", "12345") -> true ("short", "123456") -> false Note that the 'tostr' template in javaGenLibrary.xsl has very similar code and any changes should be made there too.
  - baseClassOfArray
```
public static String baseClassOfArray(String className)
```
  - baseName
```
public static String baseName(String fullClassName)
```
    This will return a name from @param fullClassName where everything upto and including the last '.' is removed. eg: "java.lang.String[]" -> "String[]" "java.util.ArrayList" -> "ArrayList"
  - getCanonicalClassName
```
public static String getCanonicalClassName(Class cls)
```
  - getOptimialHashMapSize
```
public static int getOptimialHashMapSize(Object[] keys)
```
  - getOptimialHashMapSize
```
public static int getOptimialHashMapSize(Object[] keys,
                                         int maxSize)
```
    Using reflection figure out the optimal initial capacity for a HashMap given some keys. This uses a load factor of 1.0f. By optimal, the table does not need resizing and there are no lists (or chaining) being done in a HashMap.Entry.
    
    Parameters:
    
    maxSize - the point at which to give up (the maximum size to try)
  - native2ascii
```
public static void native2ascii(Writer out,
                                Reader in)
                         throws IOException
```
    Throws:
    
    IOException
  - uencode
```
public static String uencode(char c)
```
    Take a character and return the \ u (Unicode) representation of it.
  - copyStream
```
public static int copyStream(Writer out,
                             Reader in)
                      throws IOException
```
    copyStream is not really a Java Utility method, but it's needed by one of them, and so is here.
    
    Returns:
    
    the total length of the stream (in char's) copied.
    
    Throws:
    
    IOException
  - copyStream
```
public static int copyStream(OutputStream out,
                             InputStream in)
                      throws IOException
```
    copyStream is not really a Java Utility method, but it's needed by one of them, and so is here.
    
    Returns:
    
    the total length of the stream (in char's) copied.
    
    Throws:
    
    IOException
  - reservedWord
```
public static boolean reservedWord(String name)
```

Class JavaUtil

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BUFFER_SIZE

Method Detail

toObject

toObjectType

fromObjectType

typeToString

fromObject

isImmutable

instanceFrom

escapeCharForInstance

compareTo

compareToText

genParseText

genParseText

genParseTextME

genParseText

genParseText

exceptionsFromParsingText

exceptionsFromParsingText

isPrimitiveType

getPrimitive

canProduceNoXMLMetaChars

nullValueForType

genNewDefault

exprToInt

genEquals

genEquals

isCloneable

isInstantiable

checkValueToType

baseClassOfArray

baseName

getCanonicalClassName

getOptimialHashMapSize

getOptimialHashMapSize

native2ascii

uencode

copyStream

copyStream

reservedWord