Data type mappings

Basic data types

A Variant should map to whatever data type it contains.

Java™ byte values of -128 to -1 map to LotusScript® Byte values of +128 to +255. Java™ byte values of 0 to +127 map to the same LotusScript® values, 0 to +127.

About Java™ precision and the long data type

The Java™ long data type range is:

min -2^63 == -9,223,372,036,854,775,808 == approx. -9.22337203685478E+18

max +2^63 - 1 == +9,223,372,036,854,775,807 == approx. +9.22337203685478E+18

However, because of a lack of precision in floating-point types, LS2J supports only a smaller range of approximately:

+- 9,223,372,036,854,770,000 == +- 9.22337203685477E+18

This range varies slightly by platform. LS2J throws an "Expression out of range" error if a LotusScript® value outside these limits is passed to a Java™ long data type.

Even within the supported range, only 15 digits of precision are available; that is, a Java™ long data type will map to a predictable integral LotusScript® value only within the range:

+- 1,000,000,000,000,000 == +- 1.0E+15

String mapping example

LSStrings.java:

public class LSStrings
{
	public char    F1;
	public char [] F2;
	public String F3;
	public char    M1(char p)    { return p; }
	public char [] M2(char [] p) { return p; }
	public String M3(String p) { return p; }
}

LSStrings.lss:

Option Public
Uselsx "*javacon"

Dim mySession As JavaSession

Sub Initialize
	Dim myClass As JavaClass, myObject As JavaObject, s1 As String, _
		s2 As String, s3 As String
	s1 = "A"
	s2 = "BC"
	s3 = "DE"
	Set mySession = New JavaSession ("\LSI\test\java;")
	Set myClass = mySession.GetClass("LSStrings;")
	Set myObject = myClass.CreateObject
	myObject.F1 = s1
	myObject.F2 = s2
	myObject.F3 = s3
	MsgBox myObject.F1 & myObject.F2 & myObject.F3 & _
    myObject.M1(s1) & myObject.M2(s2) & myObject.M3(s3)
	' Displays "ABCDEABCDE"
End Sub

Java™ reference types

The Java™ reference types have limited support:

• The JavaObject data type is mapped directly and dynamically into a LotusScript® ADT. You can use a LotusScript® JavaObject in places where a Java™ object is needed: for example, in Get/Set properties, arguments for JavaMethods, and return values.
• LotusScript® is only able to handle single dimension arrays of all the primitive types (byte, short, int, long, float, double, Boolean, and char). The Java™ char[ ] is mapped to the LotusScript® dynamic string type. Notice that the Java/lang/String class is mapped to a LotusScript® ADT. The following statement prints the actual text string out, assuming that myObject has a toString method, which returns a Java/lang/String object:

  		print myObject.toString().toCharArray()

  LS2J dynamically adapts the Java/lang/String class then binds to the toCharArray method. The toCharArray method returns a char[], which is automatically translated into a LotusScript® string.

Processing arguments

You can pass all primitive types and Java™ objects directly as arguments to JavaMethods. For reference types, LotusScript® does not yet support the call-by-reference semantics. You can pass single dimension arrays into a Java™ method, but the results are not copied back into the LotusScript® space. LotusScript® also does not yet support passing in arrays of Java™ objects.

Limitations

Some important limitations include:

• You can't bring a bitmap into LotusScript® because the Java™ byte (signed 8-bit) data type is mapped to LotusScript® integer.
• You can't bring an integer greater than 32 bits into LotusScript® without losing precision because the Java™ long (64 bit) data type is mapped to LotusScript® Double.

• You can use only single dimension arrays.
• There is no call-by-reference semantics for arguments of reference type.