import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
@Test
    public void testExpressionProbeAnnotation() throws RemoteException {
        CQLQuery cqlQuery = new CQLQuery();
        gov.nih.nci.cagrid.cqlquery.Object target = new gov.nih.nci.cagrid.cqlquery.Object();
        target.setName("gov.nih.nci.caarray.domain.array.ExpressionProbeAnnotation");
        cqlQuery.setTarget(target);
        Attribute[] atts = {
//            new Attribute("chromosomeName", Predicate.EQUAL_TO, "foo"),
//            new Attribute("chromosomeStartPosition", Predicate.LESS_THAN, "1"),
//            new Attribute("chromosomeEndPosition", Predicate.GREATER_THAN, "2")
        };
//        Group g = new Group(null, atts, null, LogicalOperator.AND);
//        target.setGroup(g);
        CQLQueryResults cqlResults = gridClient.query(cqlQuery);
//        assertEquals(1071, cqlResults.getObjectResult().length);
        Iterator iter = new CQLQueryResultsIterator(cqlResults, CaArraySvcClient.class.getResourceAsStream("client-config.wsdd"));
        while (iter.hasNext()) {
            ExpressionProbeAnnotation f = (ExpressionProbeAnnotation) (iter.next());
//            assertEquals("foo", f.getChromosomeName());
//            assertTrue(f.getChromosomeStartPosition().longValue() < 1L);
//            assertTrue(f.getChromosomeEndPosition().longValue() > 200L);
        }
    }
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public List<String> retrieveAllCollectionNameProjects() throws ConnectionException {
    List<String> collectionNameProjectsCollection = new ArrayList<String>();
    final CQLQuery query = new CQLQuery();
    Object target = new Object();
    target.setName("gov.nih.nci.ncia.domain.TrialDataProvenance");
    query.setTarget(target);
    QueryModifier distinctProjectModifier = new QueryModifier();
    distinctProjectModifier.setCountOnly(false);
    distinctProjectModifier.setDistinctAttribute("project");
    query.setQueryModifier(distinctProjectModifier);

    CQLQueryResults result = connectAndExecuteQuery(query);
    // Iterate Results
    if (result != null) {
        CQLQueryResultsIterator iter2 = new CQLQueryResultsIterator(result);
        while (iter2.hasNext()) {
            TargetAttribute[] obj = (TargetAttribute[]) iter2.next();
            //LOGGER.info(obj[0].getValue());
            collectionNameProjectsCollection.add(obj[0].getValue());
        }
    }
    return collectionNameProjectsCollection;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public Project[] findAllProjects() throws RemoteException {
    CQLQuery query = new CQLQuery();
    Object target = new Object();
    query.setTarget(target);
    target.setName(Project.class.getName());

    CQLQueryResults results = this.client.query(query);

    Iterator iter = new CQLQueryResultsIterator(results, this.getClass().getResourceAsStream("client-config.wsdd"));
    int count = 0;

    List<Project> projects = new ArrayList<Project>();
    // iterate and print XML
    while (iter.hasNext()) {
        Project prj = (Project) iter.next();
        projects.add(prj);
        count++;
    }

    Project[] projectsArray = new Project[count];
    return projects.toArray(projectsArray);

}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public void validateCQL2ResultSet(org.cagrid.cql2.results.CQLQueryResults results) throws SchemaValidationException {
    // make sure we are ready to go
       initializeRestrictedXSD();

       if (results == null) {
           LOG.debug("Null results passed, ignoring.");
           return;
       }

       StringWriter writer = new StringWriter();
       try {
           Utils.serializeObject(results, CqlSchemaConstants.CQL2_RESULTS_QNAME, writer);
       } catch (Exception e) {
           LOG.error(e);
           throw new SchemaValidationException("Problem serializing result set", e);
       }

       String xmlContents = writer.getBuffer().toString();
       if (LOG.isDebugEnabled()) {
           LOG.debug("RESULTS:\n" + xmlContents);
       }
       this.validator.validate(xmlContents);
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private static CQLQueryResults aggregateDcqlResults(DCQLQueryResultsCollection results) {
    CQLQueryResults cqlResults = new CQLQueryResults();
    List<CQLObjectResult> allObjectResults = new ArrayList<CQLObjectResult>();
    String targetName = null;
    for (DCQLResult result : results.getDCQLResult()) {
        CQLQueryResults singleCqlResult = result.getCQLQueryResultCollection();
        if (targetName == null) {
            targetName = singleCqlResult.getTargetClassname();
        } else {
            assertEquals("Unexpected result type found in DCQL", targetName, singleCqlResult.getTargetClassname());
        }
        CQLObjectResult[] objectResults = singleCqlResult.getObjectResult();
        assertNotNull("Data service " + result.getTargetServiceURL() + " returned non-object results!", objectResults);
        Collections.addAll(allObjectResults, objectResults);
    }
    
    // generate the aggregate query result
    CQLQueryResults aggregate = new CQLQueryResults();
    CQLObjectResult[] resultArray = new CQLObjectResult[allObjectResults.size()];
    allObjectResults.toArray(resultArray);
    aggregate.setObjectResult(resultArray);
    aggregate.setTargetClassname(targetName);
    return cqlResults;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public static CQLQueryResults aggregateDCQLResults(
    DCQLQueryResultsCollection dcqlResults, String targetClassname) {
    List<CQLObjectResult> objectResults = new LinkedList<CQLObjectResult>();
    for (DCQLResult result : dcqlResults.getDCQLResult()) {
        CQLObjectResult[] objects = result.getCQLQueryResultCollection().getObjectResult();
        if (objects != null && objects.length != 0) {
            Collections.addAll(objectResults, objects);
        }
    }
    
    // generate the aggregate query result
    CQLQueryResults aggregate = new CQLQueryResults();
    CQLObjectResult[] resultArray = new CQLObjectResult[objectResults.size()];
    objectResults.toArray(resultArray);
    aggregate.setObjectResult(resultArray);
    aggregate.setTargetClassname(targetClassname);
    
    return aggregate;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public String fetchBioassay(String id) 
	throws MalformedURIException, RemoteException
{
	 String url = "http://cagrid-portal.nci.nih.gov:8080/wsrf/services/cagrid/CaArraySvc";

		 CaArraySvcClient client = new CaArraySvcClient(url);

		 //CQLQuery query = (CQLQuery) Utils.deserializeDocument("demo.xml", CQLQuery.class);
		 CQLQuery query = new CQLQuery();
		 Object target = new Object();
		 target.setName("gov.nih.nci.mageom.domain.BioAssayData.MeasuredBioAssayData");
		 Attribute att = new Attribute("identifier", Predicate.EQUAL_TO, id);
		 target.setAttribute(att);
		 query.setTarget(target);
		 
		 CQLQueryResults results = client.query(query);

		 results.setTargetClassname("java.lang.Object");
		 CQLQueryResultsIterator iterator = new CQLQueryResultsIterator(results, true);

		 if (! iterator.hasNext()) return null;
	 String bioassay = (String) iterator.next();
	 System.out.println(bioassay);
		 return bioassay;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private List<Object> processResults(CQLQueryResults results)
		throws Exception {

	InputStream resourceAsStream = CbmCodeListTests.class
			.getResourceAsStream("client-config.wsdd");
	Iterator<?> iter = new CQLQueryResultsIterator(results,
			resourceAsStream);

	List<Object> remoteValues = new Vector<Object>();

	// Check that all retrieved values are supported by the reference code
	// list while
	while (iter.hasNext()) {
		Object rawValue = iter.next();

		remoteValues.add(rawValue);

	}
	return remoteValues;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public gov.nih.nci.cagrid.cqlresultset.CQLQueryResults executeAndAggregateResults(
    gov.nih.nci.cagrid.dcql.DCQLQuery query) throws RemoteException,
    gov.nih.nci.cagrid.fqp.stubs.types.FederatedQueryProcessingFault {
    validateQueryConstraints(query, null);
    
    FederatedQueryEngine engine = new FederatedQueryEngine(null, null, getWorkExecutorService());
    CQLQueryResults results = null;
    try {
        results = engine.executeAndAggregateResults(query);
    } catch (FederatedQueryProcessingException e) {
        LOG.error("Problem executing query: " + e.getMessage(), e);
        FederatedQueryProcessingFault fault = new FederatedQueryProcessingFault();
        fault.setFaultString("Problem executing query: " + e.getMessage());
        FaultHelper helper = new FaultHelper(fault);
        helper.addFaultCause(e);
        throw helper.getFault();
    }
    return results;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private void verifyResults(List<SOAPElement> results) {
    LOG.debug("Verifying test results");
    LOG.debug("Loading gold results from " + getGoldFilenname());
    DCQLQueryResultsCollection goldResults = loadGoldDcqlResults();
    
    // convert the list of elements into DCQL results
    DCQLQueryResultsCollection testResults = new DCQLQueryResultsCollection();
    DCQLResult testResult = new DCQLResult();
    testResult.setTargetServiceURL("http://fake.service");
    CQLQueryResults cqlResults = new CQLQueryResults();
    // what's the target classname supposed to be?
    String targetName = deserializeQuery().getTargetObject().getName();
    LOG.debug("Setting test results target classname to " + targetName);
    cqlResults.setTargetClassname(targetName);
    CQLObjectResult[] objectResults = new CQLObjectResult[results.size()];
    for (int i = 0; i < results.size(); i++) {
        CQLObjectResult obj = new CQLObjectResult();
        obj.set_any(new MessageElement[] {new MessageElement(results.get(i))});
        objectResults[i] = obj;
    }
    cqlResults.setObjectResult(objectResults);
    testResult.setCQLQueryResultCollection(cqlResults);
    testResults.setDCQLResult(new DCQLResult[] {testResult});
    
    QueryResultsVerifier.verifyDcqlResults(testResults, goldResults);
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public ImageAnnotation getImageSeriesAnnotation(String seriesInstanceUID) throws ConnectionException {
    ImageAnnotation imageAnnotation = null;
    Attribute seriesInstanceUIDAttribute = retrieveAttribute("instanceUID", Predicate.EQUAL_TO, seriesInstanceUID);
    Association seriesAssociation = retrieveAssociation("edu.northwestern.radiology.aim.Series", "series",
            seriesInstanceUIDAttribute);
    Association studyAssociation = retrieveAssociation("edu.northwestern.radiology.aim.Study", "study",
            null);
    Association dicomImageReferenceAssociation = retrieveAssociation(
            "edu.northwestern.radiology.aim.DICOMImageReference", "imageReferenceCollection", null);
    studyAssociation.setAssociation(seriesAssociation);
    dicomImageReferenceAssociation.setAssociation(studyAssociation);
    CQLQuery query = retrieveQuery("edu.northwestern.radiology.aim.ImageAnnotation",
            dicomImageReferenceAssociation);
    CQLQueryResults result = connectAndExecuteQuery(query);
    if (result != null) {
        CQLQueryResultsIterator iter = new CQLQueryResultsIterator(result, true);
        if (iter.hasNext()) {
            imageAnnotation = AIMJaxbParser.retrieveImageAnnotationFromXMLString((String) iter.next());
        }
    }
    return imageAnnotation;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private ArrayDesign lookupArrayDesign(CaArraySvcClient client, String arrayDesignName) throws RemoteException {
    CQLQuery cqlQuery = new CQLQuery();
    gov.nih.nci.cagrid.cqlquery.Object target = new gov.nih.nci.cagrid.cqlquery.Object();
    target.setName("gov.nih.nci.caarray.domain.array.ArrayDesign");
    Attribute arrayDesignNameAttribute = new Attribute();
    arrayDesignNameAttribute.setName("name");
    arrayDesignNameAttribute.setValue(arrayDesignName);
    arrayDesignNameAttribute.setPredicate(Predicate.EQUAL_TO);
    target.setAttribute(arrayDesignNameAttribute);
    cqlQuery.setTarget(target);
    CQLQueryResults cqlResults = client.query(cqlQuery);
    CQLQueryResultsIterator iter = new CQLQueryResultsIterator(cqlResults, CaArraySvcClient.class
            .getResourceAsStream("client-config.wsdd"));
    if (!(iter.hasNext())) {
        return null;
    }
    return (ArrayDesign) iter.next();
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private CaArrayFile lookupFile(String fileName) throws RemoteException {
    CQLQuery cqlQuery = new CQLQuery();
    gov.nih.nci.cagrid.cqlquery.Object target = new gov.nih.nci.cagrid.cqlquery.Object();
    target.setName("gov.nih.nci.caarray.domain.file.CaArrayFile");
    Attribute fileNameAttribute = new Attribute();
    fileNameAttribute.setName("name");
    fileNameAttribute.setValue(fileName);
    fileNameAttribute.setPredicate(Predicate.EQUAL_TO);
    target.setAttribute(fileNameAttribute);
    cqlQuery.setTarget(target);
    CQLQueryResults cqlResults = gridClient.query(cqlQuery);
    logForSilverCompatibility(API_CALL, "Grid query(CQLQuery)");
    CQLQueryResultsIterator iter = new CQLQueryResultsIterator(cqlResults, CaArraySvcClient.class
            .getResourceAsStream("client-config.wsdd"));
    return (CaArrayFile) iter.next();
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private boolean isResultOkay(CQLQueryResults cqlResults, String sampleName) {
    if (cqlResults.getObjectResult() == null) {
        return false;
    }
    Iterator iter = new CQLQueryResultsIterator(cqlResults, CaArraySvcClient.class
            .getResourceAsStream("client-config.wsdd"));
    if (!(iter.hasNext())) {
        return false;
    }
    while (iter.hasNext()) {
        Sample retrievedSample = (Sample) (iter.next());
        // Check if retrieved sample matches requested search criteria.
        logForSilverCompatibility(TRAVERSE_OBJECT_GRAPH, "Sample.getName(): " + retrievedSample.getName());
        if (!sampleName.equalsIgnoreCase(retrievedSample.getName())) {
            return false;
        }
        Set<Extract> extracts = retrievedSample.getExtracts();
        if (extracts == null) {
            logForSilverCompatibility(TRAVERSE_OBJECT_GRAPH, "Sample.getExtracts(): null");
        } else {
            logForSilverCompatibility(TRAVERSE_OBJECT_GRAPH, "Sample.getExtracts(): size = " + extracts.size());
        }
    }
    return true;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public void testCountIteration() {
    CQLQueryResults results = loadResults("countResults.xml");
    CQLQueryResultsIterator iter = new CQLQueryResultsIterator(results, false);
    assertTrue("Count iterator had no results", iter.hasNext());
    Object o = iter.next();
    assertNotNull("Count iteration result was null", o);
    assertEquals("Count iteration result was of unexpected type", Long.class, o.getClass());
    assertEquals("Count iteration result was of unexpected value", ((Long) o).longValue(), 200);
    assertFalse("Count iterator claims to have more results", iter.hasNext());
    try {
        iter.next();
        fail("Count iterator did not throw NoSuchElementException with no results to return");
    } catch (NoSuchElementException ex) {
        // expected
    }
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public void runStep() throws Throwable {
    if (LOG.isTraceEnabled()) {
        URL[] classpath = ((URLClassLoader) getClass().getClassLoader()).getURLs();
        LOG.trace("Your classpath:\n");
        for (URL u : classpath) {
            LOG.trace(u.getPath());
        }
    }
    LOG.debug("Testing with query " + getQueryFilename());
    DCQLQuery query = deserializeQuery();
    query.setTargetServiceURL(testServiceUrls);
    CQLQueryResults testResults = performAggregation(query);
    LOG.debug("Verifying against " + getGoldFilenname());
    CQLQueryResults goldResults = loadGoldCqlResults();
    StringWriter writer = new StringWriter();
    writer.write("Test results:\n");
    Utils.serializeObject(testResults, CqlSchemaConstants.CQL_RESULT_SET_QNAME, writer, 
        QueryResultsVerifier.class.getResourceAsStream(FQPTestingConstants.CLIENT_WSDD));
    writer.write("\nGoldResults:\n");
    Utils.serializeObject(goldResults, CqlSchemaConstants.CQL_RESULT_SET_QNAME, writer, 
        QueryResultsVerifier.class.getResourceAsStream(FQPTestingConstants.CLIENT_WSDD));
    System.out.println(writer.getBuffer().toString());
    QueryResultsVerifier.verifyCqlResults(testResults, goldResults);
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
/**
 * Executes a query, which is expected to be valid and compares the
 * results to gold, which is expected to be valid
 * @param query
 *      The query to execute
 * @param goldResults
 *      The gold results set
 */
private void invokeValidQueryValidResults(CQLQuery query, CQLQueryResults goldResults) {
    DataServiceClient client = getServiceClient();
    CQLQueryResults queryResults = null;
    boolean isSdkJdk6Error = false;
    try {
        queryResults = client.query(query);
        // If this fails, we need to still be able to exit the jvm
    } catch (Exception ex) {
        if (isJava6() && isSpringJava6Error(ex)) {
            // some of the datatypes don't play nice with JDK 6
            isSdkJdk6Error = true;
            LOG.debug("Query failed due to caCORE SDK incompatibility with JDK 6", ex);
        } else {
            // that's a real failure
            ex.printStackTrace();
            fail("Query failed to execute: " + ex.getMessage());
        }
    }
    if (!isSdkJdk6Error) {
        compareResults(goldResults, queryResults);
    }
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public synchronized CQLQueryResults executeAndAggregateResults(DCQLQuery query) throws RemoteException,
    FederatedQueryProcessingFault, FederatedQueryProcessingException {
    if (fqpClient == null && fqpContainerSource != null) {
        createClientFromContainer();
    }
    
    if (fqpContainerSource != null && fqpContainerSource.getServiceContainer() instanceof SecureContainer) {
        configureCaDirectory();
    }
    
    CQLQueryResults results = null;
    if (fqpClient != null) {
        results = fqpClient.executeAndAggregateResults(query);
    } else if (fqpEngine != null) {
        results = fqpEngine.executeAndAggregateResults(query);
    } else {
        throw new IllegalStateException("NO CLIENT OR ENGINE!");
    }
    
    return results;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private Sample loadSample(String sampleId) {
	Sample sample = null;
	try {
		gov.nih.nci.cagrid.cqlquery.Object target = new gov.nih.nci.cagrid.cqlquery.Object();
		target.setName("gov.nih.nci.cananolab.domain.particle.Sample");
		CQLQuery query = new CQLQuery();
		Attribute attribute = new Attribute();
		attribute.setName("id");
		attribute.setPredicate(Predicate.EQUAL_TO);
		attribute.setValue(sampleId);
		target.setAttribute(attribute);
		query.setTarget(target);
		CQLQueryResults results;
		results = gridClient.query(query);

		results.setTargetClassname("gov.nih.nci.cananolab.domain.particle.Sample");
		CQLQueryResultsIterator iter = new CQLQueryResultsIterator(results);
		while (iter.hasNext()) {
			java.lang.Object obj = iter.next();
			sample = (Sample) obj;
			logger.info("loaded sample info for " + sampleId);
		}
	} catch (Exception e) {
		logger.error("Error loading sample info for " + sampleId);
	}
	return sample;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private void findAllHelper(String target) throws Exception {
    CQLQuery query = new CQLQuery();
    query.setTarget(new gov.nih.nci.cagrid.cqlquery.Object());
    query.getTarget().setName(target);
    CQLQueryResults results = executeCQLQuery(query);
    printResults(results, "findAll." + target + ".xml");
}