For basic Java types we can define methods such as the following:

public boolean nextX()
{
    return mXOutput.getDataValueIterator().nextAsBoolean() 
}

public String nextX()
{
    mXOutput.getDataValueIterator().nextAsString() 
}

public Date nextX()
{
    mXOutput.getDataValueIterator().nextAsDate() 
}

public double nextX()
{
    mXOutput.getDataValueIterator().nextAsDouble() 
}

public float nextX()
{
    mXOutput.getDataValueIterator().nextAsFloat() 
}

public int nextX()
{
    mXOutput.getDataValueIterator().nextAsInt() 
}

public long nextX()
{
    mXOutput.getDataValueIterator().nextAsLong() 
}

If the output is an OGSA-DAI list of objects that are, or can be mapped to, simple types then we provide a two methods. One returns an object of type:

uk.org.ogsadai.client.toolkit.DataListIterator

For example:

public DataIterator nextX()
    throws DataStreamErrorException, 
           UnexpectedDataValueException, 
           DataSourceUsageException
{
    return new DataListIterator(mXOutput.getDataValueIterator(), String.class);
}

Note how the expected type of the data is provided as an argument to the DataListIterator constructor.

The other method returns an array of the appropriate type. For example:

public String[] nextXAsArray()
    throws DataStreamErrorException, 
           UnexpectedDataValueException, 
           DataSourceUsageException
{
        if (! hasNextX())
        {
            return null;
        }
        DataIterator iterator = nextData();
        List stringList = new ArrayList();
        while(iterator.hasNext())
        {
            stringList.add((String)iterator.next());
        }
        int listSize = stringList.size();
        String[] outputArray = new String[listSize];
        for(int i = 0; i < listSize; i++)
        {
            outputArray[i]  = (String)stringList.get(i);
        }
        return outputArray;
}

If the output is a list of char[] then the nextX method should returns a java.io.Reader. For example:

public Reader nextX()
{
    return new DataValueReader(mXOutput.getDataValueIterator(),1);
}

If the output is a list of byte[] then the nextX method returns a java.io.InputStream. For example:

public InputStream nextX()
{
    return new DataValueInputStream(mXOutput.getDataValueIterator(),1);
}

Of course and apart from the foregoing advice, when giving the client developer access to the data you can parse the data and so provide it in a form that might be more useful to them. One example of this is the client toolkit activity proxy:

uk.org.ogsadai.client.toolkit.activities.transform.TupleToWebRowSetCharArrays

The corresponding server-side activity has an output - result - that outputs OGSA-DAI lists of char[]. Together these character arrays form an XML WebRowSet document representing the results of an SQL query. So our client toolkit proxy provides a method:

ResultSet getResultAsResultSet()

This allows users to obtain the data in a more usable way.

For activities that support multiple outputs of the same name we need to allow the client developer to specify the index of the output whose data they want to get.This just requires our hasNextX and nextX methods to take the index of the output also. For example:

public boolean hasNextX(int index) 
    throws DataStreamErrorException, 
           UnexpectedDataValueException, 
	   DataSourceUsageException,
           ArrayIndexOutOfBounds
{
    return mXOutput.getDataValueIterator(index).hasNext();  
}
public int nextX(int index) 
    throws DataStreamErrorException,
           UnexpectedDataValueException,
           DataSourceUsageException,
           ArrayIndexOutOfBounds
{
    return mXOutput.getDataValueIterator(index).nextAsInt();
}

If an activity has its output connected the DeliverToRequestStatus activity then any data it outputs will be returned from the OGSA-DAI server to the client in the request status.

The client toolkit parses the request status and populates the ActivityOutput objects of such activities that were connected to DeliverToRequestStatus with their data.

This data is then available via the getDataValueIterator method of ActivityOutput method.

If the activity (activity A, say) is not connected directly to DeliverToRequestStatus, but there is another activity (activity B, say) in between, then if activity B does not alter the data in a way that prevents activity A from parsing the output then activity A can still obtain the data that was written to DeliverToRequestStatus, even though it was not directly connected.

However, to support this your activity must allow a client developer to tell the client proxy for A that it's data can be picked up from the request status, as it won't know this by default (it'll assume that it has no data since it was not connected to DeliverToRequestStatus itself). For example:

ActivityA activityA = new ActivityA();
ActivityB activityB = new ActivityB();
DeliverToRequestStatus deliverToRequestStatus = 
    new DeliverToRequestStatus();
activityB.connectInput(activityA.getOutput());
deliverToRequestStatus.connectInput(activityB.getOutput);

...

// Tell activity A's output that it can get its data from the request
// status.
activityA.getOutput().setResultActivity(
    deliverToRequestStatus);

This is primarily a usability and design issue. For example, a common SQL query workflow is SQLQuery => TupleToWebRowSetCharArrays => ByteArraysResize => DeliverToRequestStatus. ByteArraysResize is purely used to optimise the size of byte arrays to minimize server-client communications overheads. So it makes sense to allow client developers to get the relational data via the TupleToWebRowSetCharArrays proxy rather than the ByteArraysResize proxy. And so we often have:

SQLQuery query = new SQLQuery();
query.setResourceID(mDataResourceID);
query.addExpression(mSQLQuery);
        
TupleToWebRowSetCharArrays tuple = new TupleToWebRowSetCharArrays();
tuple.connectDataInput(query.getDataOutput());
        
CharArraysResize resize = new CharArraysResize();
resize.addSizeInChars(5000);
resize.connectDataInput(tuple.getResultOutput());

DeliverToRequestStatus deliverToRequestStatus = new DeliverToRequestStatus();
deliverToRequestStatus.connectInput(resize.getResultOutput());
        
tuple.getResultOutput().setResultActivity(deliverToRequestStatus);>