Handling Multiple Output Parameters

Question

Howdy.
What is the concensus approach for handling multiple output parameters in Java?
We have a legacy C API that we are porting to Java. All API routines already return an error value as an int. i.e.:
int foo(...);
What if we wanted to return additional info, such as a length and binary (not text) data?
int foo(...,int* len,char** data);
We use a char** for data cause we don't know in advance how long the data will be and we don't want callers to have to allocate arbitrary-sized arrays. In other words, we allocate the output data buffer internally.
How do you do this in Java? Obviously, we can use an Integer object to return the length, but passing in a byte[] for data will not return the internally allocated array to the caller:
public int foo(...,Integer len,byte[] data); // can't allocate data internally
We also thought about using ByteArrayOutputStream, but since the class does not provide direct access to the internal array, it requires an inefficient copy through the toByteArray() method in order to retrieve our data.
Any ideas?
Ricardo

Answer 1

Yes, that is the approach that we are currently
using. We have defined an Out class that incorporates
all possible output types as data members:Huh? One class that is used for all possible output types? I'm not quite sure what you mean by that. Classes should be meaningful in and of themselves, not just to encapsulate a bunch of unrelated fields. Sounds non-OO.
public class Out
byte[] out_bytes;
int      out_int;
}I guess we feel this is somewhat inelegant...
The only real problem is with the byte[] arguments.
Any thoughts on that?
Thanks,
RicardoThere's nothing inherently wrong with a byte array - else there may not be such an animal in the language. Other than the comments above about maybe it being non-OO, the only other comment I could make on this without really seeing the whole context (how this class is really used, etc) would be that yes it looks like it is just encapsulating all possible output types. Not good. If a method is going to return a byte array, it should do so - not return a meaningless "Out" object which happens to contain that array. And another method returning an int should return the int, not this "Out" object containing the int. These don't appear to be related fields belonging to an object in an OO sense.