How to use

ReferenceService

in

net.sf.taverna.t2.reference

  private Map<String,Object> buildInputMap(Map<String, T2Reference> data,ReferenceService referenceService) throws ReferenceServiceException {
    Map<String,Object> result = new HashMap<String, Object>();
    for (String inputName : data.keySet()) {
      T2Reference id = data.get(inputName);
      result.put(inputName, referenceService.renderIdentifier(id,String.class, callback.getContext()));
    }
    return result;
  }
});

private Map<String, T2Reference> createOutputData(
    Map<String, String> outputMap,ReferenceService referenceService) throws ReferenceServiceException {
  Map<String,T2Reference> result = new HashMap<String, T2Reference>();
  for (String outputName : outputMap.keySet()) {
    String xmlOut = outputMap.get(outputName);
    result.put(outputName, referenceService.register(xmlOut, 0, true, callback.getContext()));
  }
  return result;
}

/**
 * @param originalCallback
 * @param invocationContext
 * @param exceptionHandling2
 */
public ProxyCallback(AsynchronousActivityCallback originalCallback,
    InvocationContext invocationContext,
    ExceptionHandling exceptionHandling2) {
  super();
  this.originalCallback = originalCallback;
  this.exceptionHandling = exceptionHandling2;
  context = invocationContext;
  referenceService = context.getReferenceService();
  listService = referenceService.getListService();
  errorService = referenceService.getErrorDocumentService();
}

public void resultTokenProduced(WorkflowDataToken dataToken, String portname) {
  if (dataToken.getIndex().length == 0) {
    T2Reference reference = dataToken.getData();
    System.out.println("Output reference made = " + reference);
    Object value = reference;
    if (reference.containsErrors()) {
      System.out.println("Contains errors!");
      printAllErrors(context.getReferenceService().resolveIdentifier(
          reference, null, context));
    } else {
      try {
        value = context.getReferenceService().renderIdentifier(
            reference, Object.class, context);
      } catch (ReferenceServiceException ex) {
        ex.printStackTrace();
      }
    }
    resultMap.put(portname, value);
    synchronized (this) {
      outputCount--;
    }
  }
}

try {
  ReferenceSet refSet = referenceService
      .getReferenceSetService()
      .getReferenceSet(reference);
  approximateSizeInBytes = refSet.getApproximateSizeInBytes()
try {
  resolve = (String) referenceService.renderIdentifier(
      reference, String.class, null);
} catch (Exception e) {

try {
  List<?> inputNodes = (List<RDFNode>) referenceService.renderIdentifier(
      inputReference, RDFNode.class, context);
  inputPortMapping.get(portName).setValues(inputUri, inputNodes);
} catch (ReferenceServiceException e) {
  List<?> inputValues = (List<String>) referenceService.renderIdentifier(
      inputReference, String.class, context);
  inputPortMapping.get(portName).setValues(inputUri, inputValues);
outputData.put(outputPort.getName(), referenceService.register(outputPort
    .getValues(inputUri), outputPort.getDepth(), true, context));
outputPort.clearValues(inputUri);

String jsonInput = (String) referenceService.renderIdentifier(inputs.get(IN_JSON), String.class, context);
Object jsonValue;
if (outNodesText.isEmpty()) {
  ErrorDocumentService errorDocService = referenceService.getErrorDocumentService();
  ErrorDocumentService errorDocService = referenceService.getErrorDocumentService();
T2Reference firstNodeAsText = referenceService.register(textValue, 0, true, context);
T2Reference firstNodeAsJson = referenceService.register(jsonValue, 0, true, context);
outputs.put(SINGLE_VALUE_TEXT, firstNodeAsText);
outputs.put(SINGLE_VALUE_JSON, firstNodeAsJson);
  T2Reference outNodesAsText = referenceService.register(outNodesText, 1, true, context);
  outputs.put(OUT_TEXT, outNodesAsText);
  T2Reference outNodesAsXML = referenceService.register(outNodesJSON, 1, true, context);
  outputs.put(OUT_JSON, outNodesAsXML);

Object val = inputs.get(inputName);
int depth = getDepth(val);
inputEntities.put(inputName, referenceService.register(val, depth, true, callback.getContext()));
    result = referenceService.resolveIdentifier(id, null, callback.getContext());
    results.put(output.getKey(), result);
    result = referenceService.renderIdentifier(id, output.getValue(), callback.getContext());
    results.put(output.getKey(), result);

ReferenceSet rs = referenceService.getReferenceSetService().getReferenceSet(reference);
if (rs == null) {
  throw new ReferenceServiceException("Could not find ReferenceSet " + reference);
try{
  if (dataNature.equals(ReferencedDataNature.TEXT)) {
    dataValue = referenceService.renderIdentifier(reference, String.class, context);
  } else {
    dataValue = referenceService.renderIdentifier(reference, byte[].class, context);
ErrorDocument errorDocument = (ErrorDocument)referenceService.resolveIdentifier(reference, null, context);
String errorString = ResultsUtils.buildErrorDocumentString(errorDocument, context);
return errorString;
IdentifiedList<T2Reference> identifiedList = referenceService.getListService().getList(reference);
List<Object> list = new ArrayList<Object>();

  dataValue = context.getReferenceService().renderIdentifier(reference, Object.class, context);
ErrorDocument errorDocument = (ErrorDocument)context.getReferenceService().resolveIdentifier(reference, null, context);
String errorString = ResultsUtils.buildErrorDocumentString(errorDocument, context);
return errorString;
.getReferenceService().getListService().getList(reference);
List<Object> list = new ArrayList<Object>();

Object value = getInvocationContext().getReferenceService().renderIdentifier(
    getInvocationContext().getReferenceService().referenceFromString(bindings.get(0).getValue()), Object.class, getInvocationContext());
      T2Reference ref = getInvocationContext().getReferenceService().referenceFromString(record.getValue());
      Object o = getInvocationContext().getReferenceService().renderIdentifier(ref, Object.class, getInvocationContext()); 
      logger.info("\t\t\tvalue: "+o);

  results.put(cur.getKey(), ref);
} else {
  ErrorDocument ed = referenceService.getErrorDocumentService().registerError("No result for " + cur.getKey(), 0, getContext());
  results.put(cur.getKey(), ed);

List<T2Reference> idlist = listItems.get(outputName);
newDataMap.put(outputName, context.getReferenceService()
    .getListService().registerList(idlist, context).getId());

if (input.isList()) {
  IdentifiedList<T2Reference> listOfReferences = (IdentifiedList<T2Reference>) referenceService
      .getListService().getList(t2Reference);
    listFile.setTag(input.getTag());
    T2Reference listFileContentReference = referenceService
        .register(listFileContent, 0, true, invocationContext);
        .register(filenamesFileContent, 0, true, null);
    tags.put(listFile.getTag(), setOneInput(referenceService,
        filenamesFileContentReference, listFile));
            .register(outputStream.toByteArray(), 0, true,
                invocationContext);
        tags.put(input.getTag(), setOneInput(referenceService,
            .register(outputStream.toByteArray(), 0, true,
                invocationContext);
        tags.put(input.getTag(), setOneInput(referenceService,

ErrorDocument error = referenceService.getErrorDocumentService()
    .getError(reference);
element.setAttribute("id", reference.toString());
ReferenceSet referenceSet = referenceService
    .getReferenceSetService().getReferenceSet(reference);
Set<ExternalReferenceSPI> externalReferences = referenceSet
    .getExternalReferences();
  T2ReferenceType.IdentifiedList)) {
IdentifiedList<T2Reference> list = referenceService
    .getListService().getList(reference);

private FileReference getAsFileReference(ReferenceService referenceService, T2Reference t2Reference) {
  Identified identified = referenceService.resolveIdentifier(t2Reference, null, null);
  if (identified instanceof ReferenceSet) {
    for (ExternalReferenceSPI ref : ((ReferenceSet) identified).getExternalReferences()) {
      if (ref instanceof FileReference) {
        return (FileReference) ref;
      }
    }
  }
  return null;
}

private File writeDataObject(File destination, String name,
    T2Reference ref, String defaultExtension) throws IOException {
  Identified identified = referenceService.resolveIdentifier(ref, null,
      context);
    targetDir.mkdir();
    int count = 0;
    List<T2Reference> elements = referenceService.getListService().getList(ref);
    for (T2Reference subRef : elements) {
      writeDataObject(targetDir, "" + count++, subRef,

for (String key : data.keySet()) {
  Object renderIdentifier = referenceService
      .renderIdentifier(data.get(key), String.class,
          callback.getContext());
  if (isWsrfService()
    if (depth != null) {
      outputData.put(outputName, referenceService
          .register(value, depth, true, callback
              .getContext()));
    } else {
          .register(value, 0, true, callback
              .getContext()));

 for (String inputName : configBean.getActivityInputs().keySet()) {
  urlParameters.put(inputName,
           (String) referenceService.renderIdentifier(inputs.get(inputName), 
              configBean.getActivityInputs().get(inputName), context)
       );
 inputMessageBody = referenceService.renderIdentifier(
               inputs.get(IN_BODY), 
               configBean.getOutgoingDataFormat().getDataFormat(), context);
if (requestResponse.hasServerError()) {
 ErrorDocument errorDocument = referenceService.getErrorDocumentService().registerError(requestResponse.getResponseBody().toString(), 0, context);
 responseBodyRef = referenceService.register(errorDocument, 0, true, context);
 responseBodyRef = referenceService.register(requestResponse.getResponseBody(), 0, true, context);
 responseBodyRef = referenceService.register("", 0, true, context);
T2Reference statusRef = referenceService.register(requestResponse.getStatusCode(), 0, true, context);
outputs.put(OUT_STATUS, statusRef);
 T2Reference redirectionRef = referenceService.register(requestResponse.getRedirectionURL(), 0, true, context);
 outputs.put(OUT_REDIRECTION, redirectionRef);

Identified identified = context.getReferenceService().resolveIdentifier(resultReference, null, context);
MagicMatch magicMatch = null;
    data = context.getReferenceService().renderIdentifier(resultReference, Object.class, context);