How to use

ItemIterable

in

org.apache.chemistry.opencmis.client.api

  private int countResults(ItemIterable<QueryResult> iter) {
    int count = 0;
    for (Iterator<QueryResult> iterator = iter.iterator(); iterator.hasNext();) {
      iterator.next();
      count++;
    }

    return count;
  }
}

@Override
public int getTotalResults(@NotNull CMISConnector connector) throws Exception {
  long size = -1;
  long skipResultTo = pageSize * 100L;
  while (session != null && !lastPage) {
    OperationContext ctx = ChemistryCMISFacade.createOperationContext(filter, orderBy);
    final ItemIterable<QueryResult> queryResults = session.query(query, allVersions, ctx);
    final ItemIterable<QueryResult> page = queryResults.skipTo(skipResultTo).getPage();
    if (!page.getHasMoreItems()) {
      lastPage = true;
      size = skipResultTo + page.getTotalNumItems();
    }
    skipResultTo += skipResultTo;
  }
  lastPage = false;
  return (int) size;
}

@Override
public VisitorFeedbackPage getFeedbackPage(String assetId, int itemsToFetch, long itemsToSkip)
{
  ItemIterable<QueryResult> results = runQuery(MessageFormat.format(feedbackByAssetIdQueryPattern,
      assetId));
  ItemIterable<QueryResult> page = results.skipTo(itemsToSkip).getPage(itemsToFetch);
  List<VisitorFeedback> foundFeedback = new ArrayList<VisitorFeedback>((int) page.getPageNumItems());
  for (QueryResult queryResult : page)
  {
    foundFeedback.add(buildFeedbackObject(queryResult));
  }
  VisitorFeedbackPage feedbackPage = new VisitorFeedbackPageImpl(foundFeedback, itemsToSkip, 
      results.getTotalNumItems());
  return feedbackPage;
}

@Override
public List<QueryResult> getPage(@NotNull CMISConnector connector) throws Exception {
  if (session != null && !lastPage) {
    OperationContext ctx = ChemistryCMISFacade.createOperationContext(filter, orderBy);
    ctx.setMaxItemsPerPage(pageSize);
    final ItemIterable<QueryResult> queryResults = session.query(query, allVersions, ctx);
    final ItemIterable<QueryResult> page = queryResults.skipTo(skipTo).getPage();
    final List<QueryResult> results = Lists.newArrayList(page);
    if (!page.getHasMoreItems()) {
      lastPage = true;
    }
    skipTo += page.getPageNumItems();
    return results;
  }
  lastPage = false;
  return Collections.emptyList();
}

ItemIterable<QueryResult> iter1 = statement.query(false).skipTo(0).getPage(5);
int count1 = countResults(iter1);
long total1 = iter1.getTotalNumItems();
ItemIterable<QueryResult> iter2 = statement.query(false).skipTo(5).getPage(10);
int count2 = countResults(iter2);
long total2 = iter2.getTotalNumItems();

if (cresults.getTotalNumItems() == 0)
QueryResult cresult = cresults.iterator().next();
AssetCollectionImpl collection = buildCollection(cresult);    

public ItemIterable<CmisObject> getChildren(String networkId,
    String folderId, int skipCount, int maxItems,
    IncludeRelationships includeRelationships, Boolean includeAcls,
    Set<String> propertyFilter, Boolean includePolicies)
{
  CMISEndpoint cmisEndpoint = new CMISEndpoint(BindingType.BROWSER,
      CmisVersion.CMIS_1_1);
  Session session = getCMISSession(networkId, cmisEndpoint);
  CmisObject o = session.getObject(folderId);
  if (o instanceof Folder)
  {
    Folder f = (Folder) o;
    ItemIterable<CmisObject> res = f.getChildren(cmisOperationContext);
    res.skipTo(skipCount);
    ItemIterable<CmisObject> ret = res.getPage(maxItems);
    return ret;
  }
  else
  {
    throw new IllegalArgumentException(
        "Folder does not exist or is not a folder");
  }
}

public void doQuery(String cql, int maxItems) {
  Session cmisSession = getCmisSession();
  OperationContext oc = new OperationContextImpl();
  oc.setMaxItemsPerPage(maxItems);
  ItemIterable<QueryResult> results = cmisSession.query(cql, false, oc);
  for (QueryResult result : results) {
    for (PropertyData<?> prop : result.getProperties()) {
      System.out.println(prop.getQueryName() + ": " + prop.getFirstValue());
    }
    System.out.println("--------------------------------------");
  }
  System.out.println("--------------------------------------");
  System.out.println("Total number: " + results.getTotalNumItems());
  System.out.println("Has more: " + results.getHasMoreItems());
  System.out.println("--------------------------------------");
}

int i = 0;
ItemIterable<QueryResult> queryIterable = resultSet.getPage(pageSize);
for (QueryResult qr : queryIterable) {
  if (qr == null) {
addResult(assertIsFalse((i > pageSize), null, f));
if (queryIterable.getTotalNumItems() == -1) {
  addResult(createResult(WARNING, "Repository did not return numItems."));

addResult(assertIsTrue(found, null, f));
if (results.getTotalNumItems() >= 0) {
  f = createResult(FAILURE,
      "The query returned a total number of items < 1, but there must be at least one hit!");
  addResult(assertIsTrue(results.getTotalNumItems() >= 1L, null, f));

int count = 0;
for (QueryResult qr : statement.query(false).getPage(100)) {
  count++;

addResult(assertEquals(1, count, null, f));
if (results.getTotalNumItems() >= 0) {
  f = createResult(FAILURE,
      "The query returned a total number of items != 1, but there can be only exactly one hit!");
  addResult(assertEquals(1L, results.getTotalNumItems(), null, f));

context).getPage(PAGE_SIZE)) {
context).getPage(PAGE_SIZE)) {

ItemIterable<CmisObject> page1 = testFolder.getChildren(orderContext).getPage(pageSize);
for (CmisObject child : page1) {
  count++;
if (page1.getTotalNumItems() == -1) {
  addResult(createResult(WARNING, "Repository did not return numItems for the first test page."));
} else {
  f = createResult(FAILURE, "Returned numItems doesn't match the number of documents!");
  addResult(assertEquals((long) numOfDocuments, page1.getTotalNumItems(), null, f));
addResult(assertEquals(true, page1.getHasMoreItems(), null, f));
ItemIterable<CmisObject> page2 = testFolder.getChildren(orderContext).skipTo(pageSize - 1)
    .getPage(pageSize);
for (CmisObject child : page2) {
  count++;
if (page2.getTotalNumItems() == -1) {
  addResult(createResult(WARNING, "Repository did not return numItems for the second test page."));
} else {
  f = createResult(FAILURE, "Returned numItems doesn't match the number of documents!");
  addResult(assertEquals((long) numOfDocuments, page2.getTotalNumItems(), null, f));
addResult(assertEquals(true, page2.getHasMoreItems(), null, f));
ItemIterable<CmisObject> page3 = testFolder.getChildren(orderContext).skipTo(numOfDocuments - 5)
    .getPage(10);
for (@SuppressWarnings("unused")
CmisObject child : page3) {

ItemIterable<QueryResult> page = results.skipTo(query.getResultsToSkip()).getPage(query.getMaxResults());
List<SearchResult> foundAssets = new ArrayList<SearchResult>((int) page.getPageNumItems());
for (QueryResult queryResult : page)
searchResults.setTotalSize(results.getTotalNumItems());

@Override
public Collection<String> validateData(BpmTask task, boolean skipRequired) {
  if (required && !mainFolder.getChildren().iterator().hasNext()) {
    return Arrays.asList("pt.ext.cmis.list.document.validate.upload.document");
  } else {
    return null;
  }
}

if (children.getTotalNumItems() >= 0) {
  f = createResult(WARNING, "Number of children doesn't match the reported total number of items!");
  addResult(results, assertEquals(childrenCount, children.getTotalNumItems(), null, f));
} else {
  addResult(results, createResult(WARNING, "getChildren did not report the total number of items!"));

@Override
public Asset getSectionAsset(String sectionId, String resourceName, boolean wildcardsAllowedInName)
{
  Asset asset = null;
  ItemIterable<QueryResult> results = runQuery(MessageFormat
      .format((wildcardsAllowedInName ? assetBySectionAndNameWildcardQueryPattern
          : assetBySectionAndNameQueryPattern), sectionId, resourceName));
  Iterator<QueryResult> iterator = results.iterator();
  if (iterator.hasNext())
  {
    QueryResult result = iterator.next();
    asset = buildAsset(result);
  }
  return asset;
}

@Override
public Date getModifiedTimeOfAsset(String assetId)
{
  Date modifiedTime = null;
  String cmisQuery = MessageFormat.format(modifiedTimeByAssetId, assetId);
  ItemIterable<QueryResult> results = runQuery(cmisQuery);
  Iterator<QueryResult> iterator = results.iterator();
  if (iterator.hasNext())
  {
    QueryResult result = iterator.next();
    modifiedTime = SqlUtils.getDateProperty(result, Resource.PROPERTY_MODIFIED_TIME);
  }
  return modifiedTime;
}

/**
 * look for a child folder of the parent folder, if not found, create it and return it.
 */
private static Folder getOrCreateFolder(final Folder parentFolder, final String folderName)  throws IOException {
  Folder childFolder = null;
  // get existing if any
  ItemIterable<CmisObject> children = parentFolder.getChildren();
  if (children.iterator().hasNext()) {
    for (CmisObject cmisObject : children) {
      if (cmisObject instanceof Folder && cmisObject.getName().equals(folderName)) {
        log.debug("Found '{}' folder.", folderName);
        return childFolder = (Folder)cmisObject;
      }
    }
  }
  // Create new folder (requires at least type id and name of the folder)
  log.debug("'{}' folder not found, about to create...", folderName);
  Map<String, String> folderProps = new HashMap<String, String>();
  folderProps.put(PropertyIds.OBJECT_TYPE_ID, "cmis:folder");
  folderProps.put(PropertyIds.NAME, folderName);
  childFolder = parentFolder.createFolder(folderProps);
  log.info("'{}' folder created!", folderName);
  return childFolder;
}