com.googlecode.cqengine.resultset.ResultSet#iterator

Source File: ResultSets.java From cqengine with Apache License 2.0

6 votes

/**
 * Returns a Collection-like view of the given ResultSet.
 * <p/>
 * The collection simply delegates to the ResultSet, which in turn will reflect
 * any changes made to the underlying IndexedCollection by other threads.
 * For example consecutive calls to the size() method
 * may return different values if objects are added to or removed from the IndexedCollection.
 *
 * @param resultSet The ResultSet to wrap
 * @return A Collection-like view of the given ResultSet
 */
public static <O> Collection<O> asCollection(final ResultSet<O> resultSet) {
    return new AbstractCollection<O>() {
        @Override
        public Iterator<O> iterator() {
            return resultSet.iterator();
        }
        @Override
        public int size() {
            return resultSet.size();
        }

        @Override
        public boolean contains(Object o) {
            @SuppressWarnings("unchecked")
            O object = (O)o;
            return resultSet.contains(object);
        }

        @Override
        public boolean isEmpty() {
            return resultSet.isEmpty();
        }
    };
}

Source File: SQLiteObjectStore.java From cqengine with Apache License 2.0

6 votes

@Override
public CloseableIterator<O> iterator(QueryOptions queryOptions) {
    final ResultSet<O> rs = backingIndex.retrieve(has(primaryKeyAttribute), queryOptions);
    final Iterator<O> i = rs.iterator();
    class CloseableIteratorImpl extends UnmodifiableIterator<O> implements CloseableIterator<O> {

        @Override
        public boolean hasNext() {
            return i.hasNext();
        }

        @Override
        public O next() {
            return i.next();
        }

        @Override
        public void close() {
            rs.close();
        }
    }
    return new CloseableIteratorImpl();
}

Source File: OffHeapPersistenceConcurrencyTest.java From cqengine with Apache License 2.0

6 votes

@Override
public void run() {
    sequenceLog.add(taskName + " started and about to access collection");
    ResultSet<Car> backgroundResults = collection.retrieve(between(Car.CAR_ID, 40, 59));
    Iterator<Car> iterator = backgroundResults.iterator();
    int count = 0;
    for (; iterator.hasNext() && count < 5; count++) {
        iterator.next();
    }
    sequenceLog.add(taskName + " pausing mid-read");
    sleep(millisecondsToPauseMidRequest);
    sequenceLog.add(taskName + " resuming read");
    while (iterator.hasNext()) {
        iterator.next();
        count++;
    }
    backgroundResults.close();
    sequenceLog.add(taskName + " finished reading " + count + " items");
}

Source File: DiskPersistenceConcurrencyTest.java From cqengine with Apache License 2.0

6 votes

@Override
public void run() {
    sequenceLog.add(taskName + " started and about to access collection");
    ResultSet<Car> backgroundResults = collection.retrieve(between(Car.CAR_ID, 40, 59));
    Iterator<Car> iterator = backgroundResults.iterator();
    int count = 0;
    for (; iterator.hasNext() && count < 5; count++) {
        iterator.next();
    }
    sequenceLog.add(taskName + " pausing mid-read");
    sleep(millisecondsToPauseMidRequest);
    sequenceLog.add(taskName + " resuming read");
    while (iterator.hasNext()) {
        iterator.next();
        count++;
    }
    backgroundResults.close();
    sequenceLog.add(taskName + " finished reading " + count + " items");
}

Source File: CollectionQueryEngine.java From cqengine with Apache License 2.0

5 votes

Iterator<O> retrieveWithIndexOrderingMissingResults(final Query<O> query, QueryOptions queryOptions, Attribute<O, Comparable> primarySortAttribute, List<AttributeOrder<O>> allSortOrders, boolean attributeCanHaveMoreThanOneValue) {
    // Ensure that at the end of processing the request, that we close any resources we opened...
    final CloseableResourceGroup closeableResourceGroup = CloseableRequestResources.forQueryOptions(queryOptions).addGroup();

    // Retrieve missing objects from the secondary index on objects which don't have a value for the primary sort attribute...
    Not<O> missingValuesQuery = not(has(primarySortAttribute));
    ResultSet<O> missingResults = retrieveRecursive(missingValuesQuery, queryOptions);

    // Ensure that this is closed...
    closeableResourceGroup.add(missingResults);

    Iterator<O> missingResultsIterator = missingResults.iterator();
    // Filter the objects from the secondary index, to ensure they match the query...
    missingResultsIterator = filterIndexOrderingCandidateResults(missingResultsIterator, query, queryOptions);

    // Determine if we need to sort the missing objects...
    Index<O> indexForMissingObjects = standingQueryIndexes.get(missingValuesQuery);
    final List<AttributeOrder<O>> sortOrdersForBucket = determineAdditionalSortOrdersForIndexOrdering(allSortOrders, attributeCanHaveMoreThanOneValue, indexForMissingObjects, queryOptions);

    if (!sortOrdersForBucket.isEmpty()) {
        // We do need to sort the missing objects...
        Comparator<O> comparator = new AttributeOrdersComparator<O>(sortOrdersForBucket, queryOptions);
        missingResultsIterator = IteratorUtil.materializedSort(missingResultsIterator, comparator);
    }

    return missingResultsIterator;
}

Source File: TransactionalIndexedCollection.java From cqengine with Apache License 2.0

4 votes

@Override
public boolean retainAll(final Collection<?> c) {
    synchronized (writeMutex) {
        QueryOptions queryOptions = openRequestScopeResourcesIfNecessary(null);
        try {
            // Copy objects into a new set removing nulls.
            // CQEngine does not permit nulls in queries, but the spec of {@link Collection#retainAll} does.
            Set<O> objectsToRetain = new HashSet<O>(c.size());
            for (Object object : c) {
                if (object != null) {
                    @SuppressWarnings("unchecked") O o = (O)object;
                    objectsToRetain.add(o);
                }
            }
            // Prepare a query which will match objects in the collection which are not contained in the given
            // collection of objects to retain and therefore which need to be removed from the collection...
            // We prepare the query to use the same QueryOptions as above.
            // Any resources opened for the query which need to be closed,
            // will be added to the QueryOptions and closed at the end of this method.
            @SuppressWarnings("unchecked")
            ResultSet<O> objectsToRemove = super.retrieve(not(in(selfAttribute(objectType), objectsToRetain)), queryOptions);

            Iterator<O> objectsToRemoveIterator = objectsToRemove.iterator();
            if (!objectsToRemoveIterator.hasNext()) {
                return false;
            }

            // Configure new reading threads to exclude the objects we will remove,
            // then wait for this to take effect across all threads...
            incrementVersion(objectsToRemove);

            // Now remove the given objects...
            boolean modified = doRemoveAll(objectsToRemove, queryOptions);

            // Finally, remove the exclusion,
            // then wait for this to take effect across all threads...
            incrementVersion(Collections.<O>emptySet());

            return modified;
        }
        finally {
            closeRequestScopeResourcesIfNecessary(queryOptions);
        }
    }
}