Using CORBA objects in ColdFusion

Note:

As of ColdFusion (2021 release), CORBA has been removed. You can no longer use CORBA-related features, functions, and tags.

After you create the object, you can invoke attributes and operations on the object using the syntax described in Creating and using objects.

CORBA works with JDK 1.8.

Using CORBA interface methods in ColdFusion

When you use the cfobject tag or the CreateObject function to create a CORBA object, ColdFusion creates a handle to a CORBA interface: the cfobject name attribute or the CreateObject function return variable. For example, the following CFML creates a handle named myHandle:

class = "d:\temp\tester.ior" name = "myHandle" locale="visibroker">
<cfset myHandle = CreateObject("CORBA", "d:\temp\tester.ior", "IOR", "visibroker")

You use the handle name to invoke all of the interface methods, as in the following CFML:

Method name case considerations

Method names in IDL are case sensitive. However, ColdFusion is not case sensitive. Therefore, do not use methods that differ only in case in IDL.
For example, the following IDL method declarations correspond to two different methods:

testCall(in string a); // method #1
TestCall(in string a); // method #2

However, ColdFusion cannot differentiate between the two methods. If you call either method, you cannot be sure which of the two gets invoked.

Passing parameters by value (in parameters)

CORBA in parameters are always passed by value. When calling a CORBA method with a variable in ColdFusion, specify the variable name without quotation marks, as shown in the following example:

IDL	void method(in string a);
CFML	<cfset foo="my string"><cfset ret=handle.method(foo)>

Passing variables by reference (out and inout parameters)

CORBA out and inout parameters are always passed by reference. As a result, if the CORBA object modifies the value of the variable that you pass when you invoke the method, your ColdFusion page gets the modified value.
To pass a parameter by reference in ColdFusion, specify the variable name in double-quotation marks in the CORBA method. The following example shows an IDL line that defines a method with a string variable, b, that is passed in and out of the method by reference. It also shows CFML that calls this method.

IDL	void method(in string a, inout string b);
CFML	<cfset foo = "My Initial String"><cfset ret=handle.method(bar, "foo")><cfoutput>#foo#</cfoutput>

In this case, the ColdFusion variable foo corresponds to the inout parameter b. When the CFML executes, the following happens:

ColdFusion calls the method, passing it the variable by reference.
The CORBA method replaces the value passed in, "My Initial String", with some other value. Because the variable was passed by reference, this action modifies the value of the ColdFusion variable.
The cfoutput tag prints the new value of the foo variable.

Using methods with return values

Use CORBA methods that return values as you would any ColdFusion function; for example:

IDL	double method(out double a);
CFML	<cfset foo=3.1415><cfset ret=handle.method("foo")><cfoutput>#ret#</cfoutput>

Using IDL types with ColdFusion variables

ColdFusion supports specific CORBA data types and converts between CORBA types and ColdFusion data.

IDL support

The following table shows which CORBA IDL types ColdFusion supports, and whether they can be used as parameters or return variables. (NA means not applicable.)

CORBA IDL type	General support	As parameters	As return value
constants	No	No	No
attributes	Yes (for properties)	NA	NA
enum	Yes (as an integer)	Yes	Yes
union	No	No	No
sequence	Yes	Yes	Yes
array	Yes	Yes	Yes
interface	Yes	Yes	Yes
typedef	Yes	NA	NA
struct	Yes	Yes	Yes
module	Yes	NA	NA
exception	Yes	NA	NA
any	No	No	No
boolean	Yes	Yes	Yes
char	Yes	Yes	Yes
wchar	Yes	Yes	Yes
string	Yes	Yes	Yes
wstring	Yes	Yes	Yes
octet	Yes	Yes	Yes
short	Yes	Yes	Yes
long	Yes	Yes	Yes
float	Yes	Yes	Yes
double	Yes	Yes	Yes
unsigned short	Yes	Yes	Yes
unsigned long	Yes	Yes	Yes
longlong	No	No	No
unsigned longlong	No	No	No
void	Yes	NA	Yes

Data type conversion

The following table lists IDL data types and the corresponding ColdFusion data types:

IDL type	ColdFusion type
boolean	Boolean
char	One-character string
wchar	One-character string
string	String
wstring	String
octet	One-character string
short	Integer
long	Integer
float	Real number
double	Real number
unsigned short	Integer
unsigned long	Integer
void	Not applicable (returned as an empty string)
struct	Structure
enum	Integer, where 0 corresponds to the first enumerator in the enum type
array	Array (must match the array size specified in the IDL)
sequence	Array
interface	An object reference
module	Not supported (cannot dereference by module name)
exception	ColdFusion throws an exception of type coldfusion .runtime.corba.CorbaUserException
attribute	Object reference using dot notation

Boolean data considerations

ColdFusion treats any of the following as Boolean values:

True	"yes", "true", or 1
False	"no", "false", or 0

You can use any of these values with CORBA methods that take Boolean parameters, as the following code shows:

IDL

{
interface TManager
{
void testBoolean(in boolean a);
void testOutBoolean(out boolean a);
void testInoutBoolean( inout boolean a);
boolean returnBoolean ();
}
}

CFML

<cfset ret = handle.testboolean("yes")>
<cfset mybool = True>
<cfset ret = handle.testoutboolean("mybool")>
<cfoutput>#mybool#</cfoutput>
<cfset mybool = 0>
<cfset ret = handle.testinoutboolean("mybool")>
<cfoutput>#mybool#</cfoutput>
<cfset ret = handle.returnboolean()>
<cfoutput>#ret#</cfoutput>

Struct data type considerations

For IDL struct types, use ColdFusion structures. You can prevent errors by using the same case for structure key names in ColdFusion as you do for the corresponding IDL struct field names.

Enum type considerations

ColdFusion treats the enum IDL type as an integer with the index starting at 0. As a result, the first enumerator corresponds to 0, the second to 1, and so on. In the following example, the IDL enumerator a corresponds to 0, b to 1 and c to 2:

IDL

{
enum EnumType {a, b, c};
interface TManager
{
void testEnum(in EnumType a);
void testOutEnum(out EnumType a);
void testInoutEnum(inout EnumType a);
EnumType returnEnum();
}
}

CFML

In this example, the CORBA object gets called with the second (not first) entry in the enumerator.

Double-byte character considerations

If you are using an ORB that supports CORBA later than version 2.0, you do not have to do anything to support double-byte characters. Strings and characters in ColdFusion convert appropriately to wstring and wchar data when they are used. However, the CORBA 2.0 IDL specification does not support the wchar and wstring types, and uses the 8-bit Latin-1 character set to represent string data. In this case, you cannot pass parameters containing those characters, however, you can call parameters with char and string types using ColdFusion string data.

Get help faster and easier

New user?