If an activity supports multiple inputs with the same name (activity input with multiple occurences) or multiple outputs with the same name (activity output with multiple occurrences) then we need a way for the client developer to specify how many of these they require.

For such activity inputs we define a method, setNumberOfXInputs, where X is the name of the input. For example:

public void setNumberOfXInputs(int count)
{
    mXInput.setNumberOfInputs(count);
}

For such activity outputs we define a method, setNumberOfXOutputs, where X is the name of the output. For example:

public void setNumberOfXOutputs(int count)
{
    mXOutput.setNumberOfOutputs(count);
}

What happens, behind the scenes, is that the client toolkit views each ActivityInput as a collection of SingleActivityInput objects. For most activity inputs there will be just one SingleActivityInput object in the collection. For multiple inputs of the same there will be 1 to N. And, similarly for ActivityOutput objects there are associated SingleActivityOutput objects.

For activities that support multiple inputs of the same name we need to allow the client developer to specify the index of the input they want to connect to. Our connectXInput methods are therefore defined as:

public void connectXInput(int index, SingleActivityOutput output)
{
    mXInput.connect(index, output);
}

Likewise for activities that support multiple outputs of the same name we need to allow the client developer to specify the index of the output they want to connect to. Our getXOutput methods are therefore defined as:

public SingleActivityOutput getXOutput(int count)
{
    return mXOutput.getSingleActivityOutputs()[count];
}

where mXOutput is the ActivityOutput object for this output.

To allow the client to provide input values of the following types

java.lang.String   
java.lang.Boolean
java.lang.Float
java.lang.Integer
java.lang.Long
java.lang.Double 
java.lang.Date 
java.lang.Calendar

we wrap the values in associated classes from the package:

uk.org.ogsadai.data

Here are examples of add methods for each type:

public void addX(boolean x)
{
    mXInput.add(new BooleanData(x));
}

public void addX(Date x)
{
    mXInput.add(new DateData(x));
}

public void addX(double x)
{
    mXInput.add(new DoubleData(x));
}

public void addX(float x)
{
    mXInput.add(new FloatData(x));
}

public void addX(int x)
{
    mXInput.add(new IntegerData(x));
}

public void addX(long x)
{
    mXInput.add(new LongData(x));
}

public void addX(String x)
{
    mXInput.add(new StringData(x));
}

If the input is an OGSA-DAI list of objects of objects then we provide two methods that take the list of objects and add these, as well as objects representing OGSA-DAI list begin and end markers to the ActivityInput objects. The list markers are denoted using the following:

uk.org.ogsadai.data.ListBegin
uk.org.ogsadai.data.ListEnd

The first method takes a java.util.Iterator containing objects of the required type. It adds the list begin marker, then traverses the iterator wrapping the values in the appropriate wrapper as already described, then adds the list end marker. So, for example, for an OGSA-DAI list of java.lang.String we'd have:

public void addX(Iterator data)
{
    mXInput.add(ListBegin.VALUE);
    while (data.hasNext())
    {
        Object value = data.next();
        if (! (value instanceof String))
        {
            throw new IllegalArgumentException("A non-String was found!");
        }
        mXInput.add(new StringData((String)data.next));
    }
    mDataInput.add(ListEnd.VALUE);
}

The second method takes an array of objects of the required type and operates in much the same way. For example:

public void addX(String[] data)
{
    mXInput.add(ListBegin.VALUE);
    for (int i = 0; i < data.length; i++)
    {
        mDataInput.add(new StringData(data[i]));
    }
    mDataInput.add(ListEnd.VALUE);
}

If the input is a list of char[] then we need to provide an addX method that takes a java.io.Reader as input and reads chunks of char[] and adds them to the input. We provide a class that does the bulk of this work:

uk.org.ogsadai.client.toolkit.Utilities;

So the method simply becomes:

public void addX(Reader reader) throws IOException
{
    mXInput.add(ListBegin.VALUE);
    Utilities.readCharData(mXInput, reader, 2048);
    mXInput.add(ListEnd.VALUE);
}

The final argument to readCharData is just a suitable size for each character array in the list.

If the input is a list of byte[] then we need to provide an addX method that takes an InputStream as input and reads chunks of byte[] and adds them to the input. We provide a class that does the bulk of this work:

uk.org.ogsadai.client.toolkit.Utilities;

So the method simply becomes:

public void addX(InputStream stream) throws IOException
{
    mXInput.add(ListBegin.VALUE);
    Utilities.readBinaryData(mXInput, stream, 2048);
    mXInput.add(ListEnd.VALUE);
}

The final argument to readBinary is just a suitable size for each byte array in the list.

For activities that support multiple inputs of the same name we need to allow the client developer to specify the index of the input they want to connect to. This just requires our addXInput methods to take the index of the input and this to be passed with the input value itself to the ActivityInput. For example:

public void addXInput(int index, String x)
{
    mXInput.add(index, new StringData(x));
}