EPLIConversion

java.lang.Object
- com.heirloomcomputing.epli.runtime.EPLIConversion

```
public class EPLIConversion
extends java.lang.Object
```
EPLIConversion - Elastic PL/I runtime support libraries conversion methods

Author:

Heirloom Computing, Inc.

Constructor Summary

Constructors
Constructor and Description

EPLIConversion()

Constructors
Constructor and Description
`EPLIConversion()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`annoBIT(java.lang.Object X)` annoBIT - return a field's declared BIT annotation value
`static int`	`annoCHAR(java.lang.Object X)` annoCHAR - return a field's declared CHAR annotation value
`static int`	`annoDECIMALprecision(java.lang.Object X)` annoDECIMALprecision - return a field's declared DECIMAL annotation, precision value
`static int`	`annoDECIMALscale(java.lang.Object X)` annoDECIMALscale - return a field's declared DECIMAL annotation, scale value
`static java.lang.String`	`annoPIC(java.lang.Object X)` annoPIC - return a field's declared CHAR annotation value
`static boolean`	`annoVARY(java.lang.Object X)` annoVARY - return a field's declared CHAR annotation value
`static BitN`	`BitN(BitN inBits)` Runtime copy constructor of BIT(n) since BitN doesn't have one.
`static BitN`	`BitNAnd(BitN op1, BitN op2)` Runtime & operator for BIT(n) since BitN doesn't have one.
`static BitN`	`BitNNot(BitN inBits)` Runtime ^ operator for BIT(n) since BitN doesn't have one.
`static BitN`	`BitNOr(BitN op1, BitN op2)` Runtime \| operator for BIT(n) since BitN doesn't have one.
`static java.lang.String`	`bitToString(java.lang.String strB)` convert a bit string ('01011101'X) into a Java string
`static byte`	`byteValue(java.lang.Object value)` convert the value to a byte
`static BitN`	`cat(BitN bs1, BitN bs2)` concatenate BIT(n) & BIT(m) into a BIT(n+m)
`static double`	`CheckSize(double arg)` CheckSize - check invalid IEEE calculation that results in not-a-number and raise the SIZE CONDITION (my estimate for closest equivalent)
`static java.math.BigDecimal`	`CheckZeroDivide(java.math.BigDecimal arg)`
`static java.math.BigInteger`	`CheckZeroDivide(java.math.BigInteger arg)`
`static boolean`	`CheckZeroDivide(boolean arg)`
`static byte`	`CheckZeroDivide(byte arg)`
`static java.lang.Byte`	`CheckZeroDivide(java.lang.Byte arg)`
`static double`	`CheckZeroDivide(double arg)`
`static java.lang.Double`	`CheckZeroDivide(java.lang.Double arg)`
`static FixedBin`	`CheckZeroDivide(FixedBin arg)`
`static float`	`CheckZeroDivide(float arg)`
`static java.lang.Float`	`CheckZeroDivide(java.lang.Float arg)`
`static int`	`CheckZeroDivide(int arg)` CheckZeroDivide - check for ZERODIVIDE divisor and throw CONDITION
`static java.lang.Integer`	`CheckZeroDivide(java.lang.Integer arg)`
`static long`	`CheckZeroDivide(long arg)`
`static java.lang.Long`	`CheckZeroDivide(java.lang.Long arg)`
`static Picture`	`CheckZeroDivide(Picture arg)`
`static short`	`CheckZeroDivide(short arg)`
`static java.lang.Short`	`CheckZeroDivide(java.lang.Short arg)`
`static java.lang.String`	`CheckZeroDivide(java.lang.String arg)`
`static int`	`compareTo(java.lang.String a, java.lang.String b)` Runtime fixed or variable CHAR comparison following PL/I rules: IBM PL/I Lang Ref 5.1 pg68: "In the comparison of strings of unequal lengths, the shorter string is padded on the right"
`static java.lang.Object`	`derefine(java.lang.Object toObj, java.lang.Object fromObj, int offset)` derefine (reverse redefine) one object as another.
`static double`	`doubleValue(java.lang.Object value)` convert the value to a double
`static float`	`floatValue(java.lang.Object value)` convert the value to a float
`static void`	`fromBytes(java.lang.Object to, byte[] from)` fromBytes - static version of the fromBytes() or fromByteArray() non- static methods that assign a possibly-immutable object's contents from a byte array
`static java.lang.Object`	`fromBytes(java.lang.Object toModel, ByteBuilder bb)` fromBytes - static version of the fromBytes() or fromByteArray() or getBytes() non- static methods that works through a pointer of a specific type (created with "new Pointer()" or "new Pointer
`static java.lang.Object`	`fromBytes(java.lang.Object toModel, ByteBuilder bb, int offset)` fromBytes - static version of the fromBytes() or fromByteArray() or getBytes() non- static methods that works through a pointer of a specific type (created with "new Pointer()" or "new Pointer
`static java.lang.String`	`hexToString(java.lang.String strB)` convert a hex string ('12cd'X) into a Java string
`static int`	`intValue(java.lang.Object value)` convert the value to an it
`static long`	`longValue(java.lang.Object value)` convert the value to a long
`static void`	`main(java.lang.String[] args)` unit test for EPLIConversions
`static Picture`	`pictureValue(java.lang.Object value)` convert the value to a Picture
`static java.lang.Object`	`Precision(java.lang.Object arg, int precision, int scale)` Precision - adjust the precision and scale of the arg to that provided, raising the SIZE condition of such adjustment causes loss of precision.
`static java.lang.Object`	`redefine(java.lang.Object toModel, java.lang.Object fromObj, int offset)` redefine (overlay) one object as another.
`static short`	`shortValue(java.lang.Object value)` convert the value to a short
`static java.math.BigDecimal`	`toBigDecimal(java.lang.Object value)` convert the value to a BigDecimal
`static java.math.BigDecimal`	`toBigDecimal(java.lang.Object value, int P, int Q)` convert the value to a BigDecimal
`static java.math.BigInteger`	`toBigInteger(java.lang.Object value)` convert the value to a BigInteger and return it
`static java.lang.Boolean`	`toBit1(java.lang.String inString)` Runtime conversion from CHAR(m) VARYING to BIT(1)
`static BitN`	`toBitN(BitN inBitN, int len)` Runtime conversion from BIT(n) to BIT(m)
`static BitN`	`toBitN(long... inLong)` Runtime conversion from Java long to BIT(n), n>1
`static BitN`	`toBitN(java.lang.Object inObj)` Runtime conversion from Java long to BIT(n), n>1
`static java.lang.Object`	`toBitN(java.lang.Object fromValue, int len)` Runtime conversion from any Object to BIT(m)
`static BitN`	`toBitN(java.lang.String inString, int N)` Runtime conversion from CHAR(m) VARYING as a straight string "0110" or PL/I BIT(n) format "'0110'B") to BIT(n), n>1 Note: Java BitNs are considered "little endian" (rightmost is bit 0).
`static java.lang.Boolean`	`toBoolean(java.lang.Object inObj)` Dynamic conversion of any EPLI type to Boolean
`static java.lang.Byte`	`toByte(java.lang.Object value)` convert the value to a Byte
`static byte[]`	`toBytes(EPLITYPES type, java.lang.Object from)` toBytes - static version of the toBytes() or toByteArray() or getBytes() non- static methods that assign a possibly-immutable object's contents from a byte array
`static byte[]`	`toBytes(java.lang.Object from)` toBytes - static version of the toBytes() or toByteArray() or getBytes() non- static methods that assign a possibly-immutable object's contents from a byte array
`static Complex`	`toComplex(java.lang.Object value)` convert the value to a Complex
`static java.lang.Double`	`toDouble(java.lang.Object value)` convert the value to a Double
`static FixedBin`	`toFixedBin(java.lang.Object value)` convert the value to an FixedBin and return it
`static FixedBin`	`toFixedBin(java.lang.Object value, int P, int Q)` convert the value to an FixedBin and return it
`static java.lang.String`	`toFixedChar(java.lang.String inString, int len)` Simulate CHAR(n) datatypes by padding or truncating string to length
`static java.lang.Float`	`toFloat(java.lang.Object value)` convert the value to a Float
`static java.lang.Integer`	`toInteger(java.lang.Object value)` convert the value to an Integer
`static java.lang.Long`	`toLong(java.lang.Object value)` convert the value to a Long
`static Picture`	`toPicture(java.lang.Object value)` convert the value to a Picture
`static Picture`	`toPicture(java.lang.Object value, java.lang.String pic)` convert the value to an Picture and return it
`static short`	`toshort(java.math.BigDecimal obj)`
`static short`	`toshort(java.math.BigInteger obj)`
`static short`	`toshort(BitN obj)`
`static short`	`toshort(java.lang.Boolean obj)` Runtime conversion to primitive short while checking SIZE (overflow) Condition.
`static short`	`toshort(java.lang.Byte obj)`
`static short`	`toshort(java.lang.Double obj)`
`static short`	`toshort(FixedBin obj)`
`static short`	`toshort(java.lang.Float obj)`
`static short`	`toshort(java.lang.Integer obj)`
`static short`	`toshort(java.lang.Long obj)`
`static short`	`toshort(java.lang.Object obj)`
`static java.lang.Short`	`toShort(java.lang.Object value)` convert the value to a Short
`static short`	`toshort(Picture obj)`
`static short`	`toshort(java.lang.Short obj)`
`static short`	`toshort(java.lang.String obj)`
`static java.lang.String`	`toString(byte[] bytes)` Runtime conversion from n-byte byte string to n byte String
`static java.lang.String`	`toString(java.lang.Object value)` convert the value to an String and return it
`static java.lang.String`	`toString(java.lang.Object value, int len)` convert the value to a fixed or variable length String of a certain length and return it
`static java.lang.String`	`toString2(int num)` Runtime conversion from 2-byte integer to a 2 byte char
`static java.lang.String`	`toVarChar(BitN inBits)` Runtime conversion from BIT(n) to CHAR(m) VARYING
`static java.lang.String`	`toVarChar(BitN inBits, int N)` Conversion from BIT(n) to CHAR(m) VARYING
`static java.lang.String`	`toVarChar(java.lang.String inString, int maxLen)` Runtime conversion CHAR(n) or CHAR(n) VARYING to CHAR(m) VARYING
`static java.lang.String`	`toVarData(java.lang.String inString, int maxLen)` Runtime conversion CHAR(n) or CHAR(n) VARYING to CHAR(m) VARYING used in PUT DATA such that it is in a form acceptable to a GET DATA, internal single quotes are doubled

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

- Constructor Detail
  - EPLIConversion
```
public EPLIConversion()
```
- Method Detail
  - toFixedChar
```
public static java.lang.String toFixedChar(java.lang.String inString,
                                           int len)
```
    Simulate CHAR(n) datatypes by padding or truncating string to length
    
    Parameters:
    
    inString - - input string
    
    len - - defined fixed length of the string
    
    Returns:
    
    String - padded or truncated string
  - toVarChar
```
public static java.lang.String toVarChar(java.lang.String inString,
                                         int maxLen)
```
    Runtime conversion CHAR(n) or CHAR(n) VARYING to CHAR(m) VARYING
    
    Parameters:
    
    inString - - input String
    
    maxLen - - the maximum length of this var char, <=0 for no-op
    
    Returns:
    
    String - perhaps truncated
  - toVarData
```
public static java.lang.String toVarData(java.lang.String inString,
                                         int maxLen)
```
    Runtime conversion CHAR(n) or CHAR(n) VARYING to CHAR(m) VARYING used in PUT DATA such that it is in a form acceptable to a GET DATA, internal single quotes are doubled
    
    Parameters:
    
    inString - - input String
    
    maxLen - - the maximum length of this var char, <=0 for no-op
    
    Returns:
    
    String - perhaps truncated
  - toVarChar
```
public static java.lang.String toVarChar(BitN inBits)
```
    Runtime conversion from BIT(n) to CHAR(m) VARYING
    
    Parameters:
    
    inBits - - input BitN
    
    Returns:
    
    outString - padded or truncated string
  - toString
```
public static java.lang.String toString(byte[] bytes)
```
    Runtime conversion from n-byte byte string to n byte String
    
    Parameters:
    
    bytes - - byte array
    
    Returns:
    
    outString - a String of the same length converted using 'iso-8859-1' so 0xff becomes "\xff" rather than a Unicode two byte escape
  - hexToString
```
public static java.lang.String hexToString(java.lang.String strB)
```
    convert a hex string ('12cd'X) into a Java string
    
    Parameters:
    
    strB - - the input string (quoted or not) in hex
    
    Returns:
    
    a String with the hex converting using default charset
  - bitToString
```
public static java.lang.String bitToString(java.lang.String strB)
```
    convert a bit string ('01011101'X) into a Java string
    
    Parameters:
    
    strB - - the input string (quoted or not) in bits
    
    Returns:
    
    a String with the bits converting using default charset
  - toString2
```
public static java.lang.String toString2(int num)
```
    Runtime conversion from 2-byte integer to a 2 byte char
    
    Parameters:
    
    num - - 2 byte int
    
    Returns:
    
    outString - a string of 2 bytes converted using 'iso-8859-1' so 0xff becomes "\xff" rather than a Unicode two byte escape
  - toBitN
```
public static BitN toBitN(BitN inBitN,
                          int len)
```
    Runtime conversion from BIT(n) to BIT(m)
    
    Parameters:
    
    inBitN - - input BIT(n) in Java BitN format
    
    len - - number of bits in the final BitN
    
    Returns:
    
    BitN - a Java BitN representing the BIT(n), truncated or padded with 0s
  - cat
```
public static BitN cat(BitN bs1,
                       BitN bs2)
```
    concatenate BIT(n) & BIT(m) into a BIT(n+m)
    
    Parameters:
    
    bs1 - - input BIT(n) in Java BitN format
    
    bs2 - - input BIT(n) in Java BitN format
    
    Returns:
    
    BitN concatenated
  - toshort
```
public static short toshort(java.lang.Boolean obj)
```
    Runtime conversion to primitive short while checking SIZE (overflow) Condition. note: use polymorphism this time instead of a single Object parm with cascading "if (obj instanceof Type)"
  - toshort
```
public static short toshort(java.lang.Byte obj)
```
  - toshort
```
public static short toshort(java.lang.Short obj)
```
  - toshort
```
public static short toshort(java.lang.Integer obj)
```
  - toshort
```
public static short toshort(java.lang.Long obj)
```
  - toshort
```
public static short toshort(java.lang.Float obj)
```
  - toshort
```
public static short toshort(java.lang.Double obj)
```
  - toshort
```
public static short toshort(java.math.BigDecimal obj)
```
  - toshort
```
public static short toshort(java.math.BigInteger obj)
```
  - toshort
```
public static short toshort(BitN obj)
```
  - toshort
```
public static short toshort(FixedBin obj)
```
  - toshort
```
public static short toshort(Picture obj)
```
  - toshort
```
public static short toshort(java.lang.String obj)
```
  - toshort
```
public static short toshort(java.lang.Object obj)
```
  - toVarChar
```
public static java.lang.String toVarChar(BitN inBits,
                                         int N)
```
    Conversion from BIT(n) to CHAR(m) VARYING
    
    Parameters:
    
    inBits - - input BitN
    
    N - - the number of bits to return or 0 meaning the length of the BitN
    
    Returns:
    
    padded or truncated string version (not enclosed in ''B)
  - BitN
```
public static BitN BitN(BitN inBits)
```
    Runtime copy constructor of BIT(n) since BitN doesn't have one.
    
    Parameters:
    
    inBits - - input BitN
    
    Returns:
    
    BitN with duplicate values of input
  - BitNAnd
```
public static BitN BitNAnd(BitN op1,
                           BitN op2)
```
    Runtime & operator for BIT(n) since BitN doesn't have one. closest is BitN.and(), but it modifies the original. we are treating BIT(n) variable as immutable, like all other Java wrappered classes (Long, etc.)
    
    Parameters:
    
    op1 - - input BitN to and with ...
    
    op2 - - another input BitN
    
    Returns:
    
    BitN with each bit of the two inputs are anded, without modifying either input BitN
  - BitNOr
```
public static BitN BitNOr(BitN op1,
                          BitN op2)
```
    Runtime | operator for BIT(n) since BitN doesn't have one. closest is BitN.or(), but it modifies the original. we are treating BIT(n) variable as immutable, like all other Java wrappered classes (Long, etc.)
    
    Parameters:
    
    op1 - - input BitN to and with ...
    
    op2 - - another input BitN
    
    Returns:
    
    BitN with each bit of the input are orred, without modifying eotjer input BitN
  - BitNNot
```
public static BitN BitNNot(BitN inBits)
```
    Runtime ^ operator for BIT(n) since BitN doesn't have one. closest is BitN.flip(), but it modifies the original. we are treating BIT(n) variable as immutable, like all other Java wrappered classes (Long, etc.)
    
    Parameters:
    
    inBits - - input BitN
    
    Returns:
    
    BitN with each bit of the input flipped, without modifying the input BitN
  - compareTo
```
public static int compareTo(java.lang.String a,
                            java.lang.String b)
```
    Runtime fixed or variable CHAR comparison following PL/I rules: IBM PL/I Lang Ref 5.1 pg68: "In the comparison of strings of unequal lengths, the shorter string is padded on the right"
    
    Parameters:
    
    a - - first String
    
    b - - second String
    
    Returns:
    
    String.compareTo() after strings of unequal sizes are adjusted
  - toBit1
```
public static java.lang.Boolean toBit1(java.lang.String inString)
```
    Runtime conversion from CHAR(m) VARYING to BIT(1)
    
    Parameters:
    
    inString - - input string in PL/I bit string format
    
    Returns:
    
    BitN - a Java Boolean representing the (possibly truncated) bitset value
  - toBitN
```
public static BitN toBitN(java.lang.String inString,
                          int N)
```
    Runtime conversion from CHAR(m) VARYING as a straight string "0110" or PL/I BIT(n) format "'0110'B") to BIT(n), n>1 Note: Java BitNs are considered "little endian" (rightmost is bit 0). A PL/I BIT(5) constant '00101'B is a BitN(5) initialized with .set(0) .set(3) and is thus '00101' with bits 0 and 5 set
    
    Parameters:
    
    inString - - input string in PL/I bit string format
    
    N - - number of bits, 0 if N is to be determined from string length
    
    Returns:
    
    BitN - a Java BitN representing the BIT(N)
  - toBitN
```
public static BitN toBitN(long... inLong)
```
    Runtime conversion from Java long to BIT(n), n>1
    
    Parameters:
    
    inLong - - input long number in little endian, probably represented as a Java binary constant in generated source "0b001100". multiple longs can be supplied or a long array supplied for n>64
    
    Returns:
    
    BitN - a Java BitN representing the BIT(N)
  - toBitN
```
public static BitN toBitN(java.lang.Object inObj)
```
    Runtime conversion from Java long to BIT(n), n>1
    
    Parameters:
    
    inObj - - input Object of any EPLI type in little endian, probably represented as a Java binary constant in generated source "0b001100". multiple longs can be supplied or a long array supplied for n>64
    
    Returns:
    
    BitN - a Java BitN representing the BIT(N)
  - toBitN
```
public static java.lang.Object toBitN(java.lang.Object fromValue,
                                      int len)
```
    Runtime conversion from any Object to BIT(m)
    
    Parameters:
    
    fromValue - - input Object of any EPLI type
    
    len - - number of bits in the final BitN
    
    Returns:
    
    BitN - a Java BitN representing the BIT(n), truncated or padded with 0s
  - toBoolean
```
public static java.lang.Boolean toBoolean(java.lang.Object inObj)
```
    Dynamic conversion of any EPLI type to Boolean
    
    Parameters:
    
    inObj - - input string
    
    Returns:
    
    String - padded or truncated string
  - fromBytes
```
public static void fromBytes(java.lang.Object to,
                             byte[] from)
```
    fromBytes - static version of the fromBytes() or fromByteArray() non- static methods that assign a possibly-immutable object's contents from a byte array
    
    Parameters:
    
    to - - an EPLI object such as Group, Integer, Short, FixedBin, BigDecimal, String
    
    from - - the byte array
  - fromBytes
```
public static java.lang.Object fromBytes(java.lang.Object toModel,
                                         ByteBuilder bb,
                                         int offset)
```
    fromBytes - static version of the fromBytes() or fromByteArray() or getBytes() non- static methods that works through a pointer of a specific type (created with "new Pointer
    ()" or "new Pointer

Class EPLIConversion

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

EPLIConversion

Method Detail

toFixedChar

toVarChar

toVarData

toVarChar

toString

hexToString

bitToString

toString2

toBitN

cat

toshort

toshort

toshort

toshort

toshort

toshort

toshort

toshort

toshort

toshort

toshort

toshort

toshort

toshort

toVarChar

BitN

BitNAnd

BitNOr

BitNNot

compareTo

toBit1

toBitN

toBitN

toBitN

toBitN

toBoolean

fromBytes

fromBytes

fromBytes

toBytes

toBytes

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckZeroDivide

CheckSize

Precision

intValue

toInteger

shortValue

toShort

longValue

toLong

byteValue

toByte

floatValue

toFloat

doubleValue

toDouble