rik/jlibcom
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

SF2963102 use varargs in Dispatch instead of a million overloaded methods

Browse Source
This commit is contained in:
clay_shooter
2010-11-07 15:36:32 +00:00
parent f0204690cc
commit 623c6e9b6b
16 changed files with 174 additions and 649 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
src/com/jacob/activeX/ActiveXComponent.java
View File

@@ -117,9 +117,9 @@ public class ActiveXComponent extends Dispatch {
}
/**
* Most code should use the standard ActiveXComponent(String) constructor and
* not this factory method. This method exists for applications that need
* special behavior. <B>Experimental in release 1.9.2.</B>
* Most code should use the standard ActiveXComponent(String) constructor
* and not this factory method. This method exists for applications that
* need special behavior. <B>Experimental in release 1.9.2.</B>
* <p>
* Factory that returns a Dispatch wrapped around the result of a
* getActiveObject() call. This differs from the standard constructor in
@@ -150,6 +150,7 @@ public class ActiveXComponent extends Dispatch {
/**
* @see com.jacob.com.Dispatch#finalize()
*/
@Override
protected void finalize() {
super.finalize();
}
@@ -382,58 +383,12 @@ public class ActiveXComponent extends Dispatch {
* makes a dispatch call for the passed in action and single parameter
*
* @param callAction
* @param parameter
* @param parameters
* @return ActiveXComponent representing the results of the call
*/
public ActiveXComponent invokeGetComponent(String callAction,
Variant parameter) {
return new ActiveXComponent(invoke(callAction, parameter).toDispatch());
}
/**
* makes a dispatch call for the passed in action and single parameter
*
* @param callAction
* @param parameter1
* @param parameter2
* @return ActiveXComponent representing the results of the call
*/
public ActiveXComponent invokeGetComponent(String callAction,
Variant parameter1, Variant parameter2) {
return new ActiveXComponent(invoke(callAction, parameter1, parameter2)
.toDispatch());
}
/**
* makes a dispatch call for the passed in action and single parameter
*
* @param callAction
* @param parameter1
* @param parameter2
* @param parameter3
* @return ActiveXComponent representing the results of the call
*/
public ActiveXComponent invokeGetComponent(String callAction,
Variant parameter1, Variant parameter2, Variant parameter3) {
return new ActiveXComponent(invoke(callAction, parameter1, parameter2,
parameter3).toDispatch());
}
/**
* makes a dispatch call for the passed in action and single parameter
*
* @param callAction
* @param parameter1
* @param parameter2
* @param parameter3
* @param parameter4
* @return ActiveXComponent representing the results of the call
*/
public ActiveXComponent invokeGetComponent(String callAction,
Variant parameter1, Variant parameter2, Variant parameter3,
Variant parameter4) {
return new ActiveXComponent(invoke(callAction, parameter1, parameter2,
parameter3, parameter4).toDispatch());
Variant... parameters) {
return new ActiveXComponent(invoke(callAction, parameters).toDispatch());
}
/**
@@ -499,61 +454,6 @@ public class ActiveXComponent extends Dispatch {
new Variant(parameter2));
}
/**
* makes a dispatch call for the passed in action and single parameter
*
* @param callAction
* @param parameter
* @return a Variant but that may be null for some calls
*/
public Variant invoke(String callAction, Variant parameter) {
return Dispatch.call(this, callAction, parameter);
}
/**
* makes a dispatch call for the passed in action and two parameter
*
* @param callAction
* @param parameter1
* @param parameter2
* @return a Variant but that may be null for some calls
*/
public Variant invoke(String callAction, Variant parameter1,
Variant parameter2) {
return Dispatch.call(this, callAction, parameter1, parameter2);
}
/**
* makes a dispatch call for the passed in action and two parameter
*
* @param callAction
* @param parameter1
* @param parameter2
* @param parameter3
* @return Variant result data
*/
public Variant invoke(String callAction, Variant parameter1,
Variant parameter2, Variant parameter3) {
return Dispatch.call(this, callAction, parameter1, parameter2,
parameter3);
}
/**
* calls call() with 4 variant parameters
*
* @param callAction
* @param parameter1
* @param parameter2
* @param parameter3
* @param parameter4
* @return Variant result data
*/
public Variant invoke(String callAction, Variant parameter1,
Variant parameter2, Variant parameter3, Variant parameter4) {
return Dispatch.call(this, callAction, parameter1, parameter2,
parameter3, parameter4);
}
/**
* makes a dispatch call for the passed in action and no parameter
*
@@ -572,7 +472,7 @@ public class ActiveXComponent extends Dispatch {
* @param args
* @return Variant returned by the invoke (Dispatch.callN)
*/
public Variant invoke(String name, Variant[] args) {
public Variant invoke(String name, Variant... args) {
return Dispatch.callN(this, name, args);
}

568
src/com/jacob/com/Dispatch.java
View File

@@ -1,21 +1,19 @@
/*
* Copyright (c) 1999-2004 Sourceforge JACOB Project.
* All rights reserved. Originator: Dan Adler (http://danadler.com).
* Get more information about JACOB at http://sourceforge.net/projects/jacob-project
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Copyright (c) 1999-2004 Sourceforge JACOB Project. All rights reserved. Originator: Dan Adler
* (http://danadler.com). Get more information about JACOB at
* http://sourceforge.net/projects/jacob-project
*
* This library is free software; you can redistribute it and/or modify it under the terms of the
* GNU Lesser General Public License as published by the Free Software Foundation; either version
* 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
* even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* You should have received a copy of the GNU Lesser General Public License along with this library;
* if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*/
package com.jacob.com;
@@ -235,6 +233,7 @@ public class Dispatch extends JacobObject {
*
* @see java.lang.Object#finalize()
*/
@Override
protected void finalize() {
safeRelease();
}
@@ -244,6 +243,7 @@ public class Dispatch extends JacobObject {
*
* @see com.jacob.com.JacobObject#safeRelease()
*/
@Override
public void safeRelease() {
super.safeRelease();
if (isAttached()) {
@@ -380,11 +380,10 @@ public class Dispatch extends JacobObject {
* an array of argument objects
*/
public static void callSubN(Dispatch dispatchTarget, String name,
Object[] args) {
Object... args) {
throwIfUnattachedDispatch(dispatchTarget);
invokeSubv(dispatchTarget, name, Dispatch.Method | Dispatch.Get,
VariantUtilities.objectsToVariants(args),
new int[args.length]);
VariantUtilities.objectsToVariants(args), new int[args.length]);
}
/**
@@ -394,11 +393,10 @@ public class Dispatch extends JacobObject {
* an array of argument objects
*/
public static void callSubN(Dispatch dispatchTarget, int dispID,
Object[] args) {
Object... args) {
throwIfUnattachedDispatch(dispatchTarget);
invokeSubv(dispatchTarget, dispID, Dispatch.Method | Dispatch.Get,
VariantUtilities.objectsToVariants(args),
new int[args.length]);
VariantUtilities.objectsToVariants(args), new int[args.length]);
}
/*
@@ -450,11 +448,10 @@ public class Dispatch extends JacobObject {
* @return Variant returned by call
*/
public static Variant callN(Dispatch dispatchTarget, String name,
Object[] args) {
Object... args) {
throwIfUnattachedDispatch(dispatchTarget);
return invokev(dispatchTarget, name, Dispatch.Method | Dispatch.Get,
VariantUtilities.objectsToVariants(args),
new int[args.length]);
VariantUtilities.objectsToVariants(args), new int[args.length]);
}
/**
@@ -464,11 +461,10 @@ public class Dispatch extends JacobObject {
* @return Variant returned by call
*/
public static Variant callN(Dispatch dispatchTarget, int dispID,
Object[] args) {
Object... args) {
throwIfUnattachedDispatch(dispatchTarget);
return invokev(dispatchTarget, dispID, Dispatch.Method | Dispatch.Get,
VariantUtilities.objectsToVariants(args),
new int[args.length]);
VariantUtilities.objectsToVariants(args), new int[args.length]);
}
/**
@@ -536,128 +532,13 @@ public class Dispatch extends JacobObject {
/**
* @param dispatchTarget
* @param name
* @param a1
* @param attributes
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, String name, Object a1) {
public static Variant call(Dispatch dispatchTarget, String name,
Object... attributes) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, name, new Object[] { a1 });
}
/**
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, String name, Object a1,
Object a2) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, name, new Object[] { a1, a2 });
}
/**
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, name, new Object[] { a1, a2, a3 });
}
/**
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @return Variant retuned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, name, new Object[] { a1, a2, a3, a4 });
}
/**
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4, Object a5) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, name, new Object[] { a1, a2, a3, a4, a5 });
}
/**
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @return Variant retuned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, name, new Object[] { a1, a2, a3, a4, a5,
a6 });
}
/**
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @param a7
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, name, new Object[] { a1, a2, a3, a4, a5,
a6, a7 });
}
/**
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @param a7
* @param a8
* @return Variant retuned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6, Object a7,
Object a8) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, name, new Object[] { a1, a2, a3, a4, a5,
a6, a7, a8 });
return callN(dispatchTarget, name, attributes);
}
/**
@@ -673,129 +554,15 @@ public class Dispatch extends JacobObject {
/**
* @param dispatchTarget
* @param dispid
* @param a1
* @param attributes
* var arg list of attributes that will be passed to the
* underlying function
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, int dispid, Object a1) {
public static Variant call(Dispatch dispatchTarget, int dispid,
Object... attributes) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, dispid, new Object[] { a1 });
}
/**
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, int dispid, Object a1,
Object a2) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, dispid, new Object[] { a1, a2 });
}
/**
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, dispid, new Object[] { a1, a2, a3 });
}
/**
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4 });
}
/**
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4, Object a5) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, dispid,
new Object[] { a1, a2, a3, a4, a5 });
}
/**
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4, a5,
a6 });
}
/**
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @param a7
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4, a5,
a6, a7 });
}
/**
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @param a7
* @param a8
* @return Variant returned by underlying callN
*/
public static Variant call(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6, Object a7,
Object a8) {
throwIfUnattachedDispatch(dispatchTarget);
return callN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4, a5,
a6, a7, a8 });
return callN(dispatchTarget, dispid, attributes);
}
/*
@@ -910,8 +677,8 @@ public class Dispatch extends JacobObject {
public static void invokeSub(Dispatch dispatchTarget, String name,
int dispid, int lcid, int wFlags, Object[] oArg, int[] uArgErr) {
throwIfUnattachedDispatch(dispatchTarget);
invokeSubv(dispatchTarget, name, dispid, lcid, wFlags,
VariantUtilities.objectsToVariants(oArg), uArgErr);
invokeSubv(dispatchTarget, name, dispid, lcid, wFlags, VariantUtilities
.objectsToVariants(oArg), uArgErr);
}
/*
@@ -968,133 +735,14 @@ public class Dispatch extends JacobObject {
*
* @param dispatchTarget
* @param name
* @param a1
* @param attributes
* var args list of attributes to be passed to underlying
* functions
*/
public static void callSub(Dispatch dispatchTarget, String name, Object a1) {
public static void callSub(Dispatch dispatchTarget, String name,
Object... attributes) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, name, new Object[] { a1 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param name
* @param a1
* @param a2
*/
public static void callSub(Dispatch dispatchTarget, String name, Object a1,
Object a2) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, name, new Object[] { a1, a2 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
*/
public static void callSub(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, name, new Object[] { a1, a2, a3 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
*/
public static void callSub(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, name, new Object[] { a1, a2, a3, a4 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
*/
public static void callSub(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4, Object a5) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, name, new Object[] { a1, a2, a3, a4, a5 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
*/
public static void callSub(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, name, new Object[] { a1, a2, a3, a4, a5, a6 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @param a7
*/
public static void callSub(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, name, new Object[] { a1, a2, a3, a4, a5, a6,
a7 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param name
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @param a7
* @param a8
*/
public static void callSub(Dispatch dispatchTarget, String name, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6, Object a7,
Object a8) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, name, new Object[] { a1, a2, a3, a4, a5, a6,
a7, a8 });
callSubN(dispatchTarget, name, attributes);
}
/**
@@ -1113,132 +761,14 @@ public class Dispatch extends JacobObject {
*
* @param dispatchTarget
* @param dispid
* @param a1
* @param attributes
* var args list of attributes to be passed to underlying
* function
*/
public static void callSub(Dispatch dispatchTarget, int dispid, Object a1) {
public static void callSub(Dispatch dispatchTarget, int dispid,
Object... attributes) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, dispid, new Object[] { a1 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
*/
public static void callSub(Dispatch dispatchTarget, int dispid, Object a1,
Object a2) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, dispid, new Object[] { a1, a2 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
*/
public static void callSub(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3) {
callSubN(dispatchTarget, dispid, new Object[] { a1, a2, a3 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
*/
public static void callSub(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
*/
public static void callSub(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4, Object a5) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4, a5 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
*/
public static void callSub(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, dispid,
new Object[] { a1, a2, a3, a4, a5, a6 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @param a7
*/
public static void callSub(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) {
throwIfUnattachedDispatch(dispatchTarget);
callSubN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4, a5, a6,
a7 });
}
/**
* makes call to native callSubN
*
* @param dispatchTarget
* @param dispid
* @param a1
* @param a2
* @param a3
* @param a4
* @param a5
* @param a6
* @param a7
* @param a8
*/
public static void callSub(Dispatch dispatchTarget, int dispid, Object a1,
Object a2, Object a3, Object a4, Object a5, Object a6, Object a7,
Object a8) {
callSubN(dispatchTarget, dispid, new Object[] { a1, a2, a3, a4, a5, a6,
a7, a8 });
callSubN(dispatchTarget, dispid, attributes);
}
/*
@@ -1315,4 +845,4 @@ public class Dispatch extends JacobObject {
throw new NotImplementedException("not implemented yet");
}
}
}

1
src/com/jacob/com/JacobObject.java
View File

@@ -63,7 +63,6 @@ public class JacobObject {
"true".equalsIgnoreCase(System.getProperty("com.jacob.debug"));
protected static boolean isDebugEnabled() {
// return true;
return DEBUG;
}

13
src/com/jacob/com/VariantUtilities.java
View File

@@ -213,11 +213,16 @@ public final class VariantUtilities {
*/
protected static Variant[] objectsToVariants(
Object[] arrayOfObjectsToBeConverted) {
Variant vArg[] = new Variant[arrayOfObjectsToBeConverted.length];
for (int i = 0; i < arrayOfObjectsToBeConverted.length; i++) {
vArg[i] = objectToVariant(arrayOfObjectsToBeConverted[i]);
if (arrayOfObjectsToBeConverted instanceof Variant[]) {
// just return the passed in array if it is a Variant array
return (Variant[]) arrayOfObjectsToBeConverted;
} else {
Variant vArg[] = new Variant[arrayOfObjectsToBeConverted.length];
for (int i = 0; i < arrayOfObjectsToBeConverted.length; i++) {
vArg[i] = objectToVariant(arrayOfObjectsToBeConverted[i]);
}
return vArg;
}
return vArg;
}
/**