public synchronized void appendBuffer(long initialTimestamp, MemoryBuffer buffer)
      throws TException, IOException {
    // filter out empty records but add a warning to the alert log
    Predicate<LogRecord> isNonEmpty =
        new Predicate<LogRecord>() {
          public boolean apply(LogRecord r) {
            if (!isValidRecord(r)) {
              throw new RuntimeException(
                  String.format(
                      "At least one of the records was missing a docid: code=%s | fields: %s | vars: %s | categories: %s",
                      r.get_index_code(), r.get_fields(), r.get_variables(), r.get_categories()));
            }
            if (!r.is_set_docid()) {
              alertLogger.warn("Tried to append an empty record for index %s", r.get_index_code());
              return false;
            }
            return true;
          }
        };

    // write the actual segment
    Segment.createUnsortedSegment(
        root,
        getSegmentsPath(),
        initialTimestamp,
        Iterators.filter(
            new RecordIterator(
                null, buffer.protocol, "Buffer for " + this.code + " at " + initialTimestamp),
            isNonEmpty));

    sort(false);
  }
    @Override
    public FollowElement createFollowElement(AbstractElement current, int lookAhead) {
      if (logger.isDebugEnabled()) logger.debug("Creating FollowElement for: " + current);
      FollowElement result = new FollowElement();
      result.setLookAhead(lookAhead);
      if (lookAhead != 1) {
        int from = input.index();
        int to = input.size();
        if (marked > 0) {
          from = firstMarker;
        }
        List<LookAheadTerminal> lookAheadTerminals = Lists.newArrayListWithExpectedSize(to - from);
        for (int tokenIndex = from; tokenIndex < to; tokenIndex++) {
          Token token = input.get(tokenIndex);

          if (token != null) {
            LookAheadTerminal lookAheadTerminal = createLookAheadTerminal(token);
            lookAheadTerminals.add(lookAheadTerminal);
          }
        }
        result.setLookAheadTerminals(lookAheadTerminals);
        result.setLookAhead(lookAheadTerminals.size() + 1);
      }
      result.setGrammarElement(current);
      result.setTrace(
          Lists.newArrayList(Iterators.filter(grammarElements.iterator(), AbstractElement.class)));
      result.setLocalTrace(
          Lists.newArrayList(Iterators.filter(localTrace.iterator(), AbstractElement.class)));
      result.setParamStack(Lists.newArrayList(paramStack));
      if (current instanceof UnorderedGroup) {
        if (indexToHandledElements != null) {
          int index = grammarElements.lastIndexOf(current);
          List<AbstractElement> alreadyHandled =
              Lists.newArrayList(
                  Iterators.filter(
                      indexToHandledElements.get(index).iterator(), AbstractElement.class));
          result.setHandledUnorderedGroupElements(alreadyHandled);
        } else {
          result.setHandledUnorderedGroupElements(Collections.<AbstractElement>emptyList());
        }
      }
      if (logger.isDebugEnabled()) {
        logger.debug("FollowElement is: " + current);
        logger.debug("==================================");
      }
      return result;
    }
 /**
  * TODO - make Generator aware of Iterator.
  *
  * @param context
  * @param component
  * @return
  */
 protected Iterable<MessageForRender> getVisibleMessages(
     FacesContext context, UIComponent component) {
   String forId = getFor(component);
   Iterator<MessageForRender> messages = getMessages(context, forId, component);
   UnmodifiableIterator<MessageForRender> filteredMessages =
       Iterators.filter(messages, getMessagesLevelFilter(context, component));
   return Lists.newArrayList(filteredMessages);
 }
 public Iterable<Tag> in(Resource r) {
   Iterator<Task> tasks = Iterators.filter(r.getAllContents(), Task.class);
   Iterable<Tag> result = Collections.emptyList();
   while (tasks.hasNext()) {
     result = concat(tasks.next().getTags(), result);
   }
   return result;
 }
  @SuppressWarnings("unchecked")
  private Iterator<Node> getBlankNodesIterator() throws RepositoryException {
    final Iterator<Property> properties = resource().getNode().getProperties();

    final Iterator<Property> references =
        Iterators.filter(
            properties, uncheck((final Property p) -> REFERENCE_TYPES.contains(p.getType()))::test);

    final Iterator<Node> nodes =
        Iterators.transform(
            new PropertyValueIterator(references),
            UncheckedFunction.uncheck(
                    (final Value v) ->
                        v.getType() == PATH
                            ? session().getNode(v.getString())
                            : session().getNodeByIdentifier(v.getString()))
                ::apply);

    return Iterators.filter(nodes, isSkolemNode::test);
  }
 /**
  * Do the actual work and move the original documents content to a new one.
  *
  * @return the aggregated document.
  */
 public Document merge() {
   Document result = MarkupFactory.eINSTANCE.createDocument();
   for (Document root : roots) {
     Iterator<Section> it = Iterators.filter(root.eAllContents(), Section.class);
     while (it.hasNext()) {
       Section sec = it.next();
       sec.setLevel(sec.getLevel() + 1);
     }
     result.getContent().addAll(root.getContent());
   }
   return result;
 }
Beispiel #7
0
  /**
   * Stages the object addressed by {@code pathFilter}, or all unstaged objects if {@code pathFilter
   * == null} to be added, if it is/they are marked as an unstaged change. Does nothing otherwise.
   *
   * <p>To stage changes not yet staged, a diff tree walk is performed using the current staged
   * {@link RevTree} as the old object and the current unstaged {@link RevTree} as the new object.
   * Then all the differences are traversed and the staged tree is updated with the changes reported
   * by the diff walk (neat).
   *
   * @param progress the progress listener for this process
   * @param pathFilter the filter to use
   */
  public void stage(final ProgressListener progress, final @Nullable String pathFilter) {

    // short cut for the case where the index is empty and we're staging all changes in the
    // working tree, so it's just a matter of updating the index ref to working tree RevTree id
    if (null == pathFilter
        && !index().getStaged(null).hasNext()
        && !updateOnly
        && index().countConflicted(null) == 0) {
      progress.started();
      Optional<ObjectId> workHead = command(RevParse.class).setRefSpec(Ref.WORK_HEAD).call();
      if (workHead.isPresent()) {
        command(UpdateRef.class).setName(Ref.STAGE_HEAD).setNewValue(workHead.get()).call();
      }
      progress.setProgress(100f);
      progress.complete();
      return;
    }

    final long numChanges = workingTree().countUnstaged(pathFilter).count();

    Iterator<DiffEntry> unstaged = workingTree().getUnstaged(pathFilter);

    if (updateOnly) {
      unstaged =
          Iterators.filter(
              unstaged,
              new Predicate<DiffEntry>() {
                @Override
                public boolean apply(@Nullable DiffEntry input) {
                  // HACK: avoid reporting changed trees
                  if (input.isChange() && input.getOldObject().getType().equals(TYPE.TREE)) {
                    return false;
                  }
                  return input.getOldObject() != null;
                }
              });
    }

    index().stage(progress, unstaged, numChanges);

    List<Conflict> conflicts = index().getConflicted(pathFilter);
    ConflictsDatabase conflictsDatabase = conflictsDatabase();
    for (Conflict conflict : conflicts) {
      // if we are staging unmerged files, the conflict should get solved. However, if the
      // working index object is the same as the staging area one (for instance, after running
      // checkout --ours), it will not be reported by the getUnstaged method. We solve that
      // here.
      conflictsDatabase.removeConflict(null, conflict.getPath());
    }
  }
 private void removeExpensiveXtextAnnotations(IProgressMonitor monitor) {
   List<Annotation> issues = Lists.newArrayList();
   Iterator<XtextAnnotation> xtext =
       Iterators.filter(fAnnotationModel.getAnnotationIterator(), XtextAnnotation.class);
   while (xtext.hasNext() && !monitor.isCanceled()) {
     final XtextAnnotation annotation = xtext.next();
     Issue issue = annotation.getIssue();
     if (!annotation.isMarkedDeleted()
         && isRelevantAnnotationType(annotation.getType())
         && issue.getType() == CheckType.EXPENSIVE) {
       issues.add(annotation);
     }
   }
   updateAnnotations(monitor, issues, Maps.<Annotation, Position>newHashMap());
 }
Beispiel #9
0
  private Iterator<SimpleFeature> filter(
      Iterator<SimpleFeature> plainFeatures, final ObjectId filterFeatureTypeId) {

    return Iterators.filter(
        plainFeatures,
        new Predicate<SimpleFeature>() {
          @Override
          public boolean apply(SimpleFeature input) {
            RevFeatureType type;
            type = (RevFeatureType) input.getUserData().get(RevFeatureType.class);
            ObjectId metadataId = type.getId();
            boolean applies = filterFeatureTypeId.equals(metadataId);
            return applies;
          }
        });
  }
Beispiel #10
0
  private Iterator<SimpleFeature> force(
      Iterator<SimpleFeature> plainFeatures, final ObjectId forceMetadataId) {

    return Iterators.filter(
        plainFeatures,
        new Predicate<SimpleFeature>() {
          @Override
          public boolean apply(SimpleFeature input) {
            RevFeatureType type;
            type = (RevFeatureType) input.getUserData().get(RevFeatureType.class);
            ObjectId metadataId = type.getId();
            if (!forceMetadataId.equals(metadataId)) {
              throw new GeoToolsOpException(StatusCode.MIXED_FEATURE_TYPES);
            }
            return true;
          }
        });
  }
 private void removeExpensiveAndFastMarkerAnnotations(IProgressMonitor monitor) {
   // every markerAnnotation produced by fast validation can be marked as deleted.
   // If its predicate still holds, the validation annotation will be covered anyway.
   Iterator<MarkerAnnotation> annotationIterator =
       Iterators.filter(fAnnotationModel.getAnnotationIterator(), MarkerAnnotation.class);
   while (annotationIterator.hasNext() && !monitor.isCanceled()) {
     final MarkerAnnotation annotation = annotationIterator.next();
     if (!annotation.isMarkedDeleted()) {
       try {
         IMarker marker = annotation.getMarker();
         if (isRelevantAnnotationType(annotation.getType())
             && marker.isSubtypeOf(MarkerTypes.EXPENSIVE_VALIDATION)) {
           annotation.markDeleted(true);
           queueOrFireAnnotationChangedEvent(annotation);
         }
       } catch (CoreException e) {
         // marker type cannot be resolved - keep state of annotation
       }
     }
   }
 }
Beispiel #12
0
  public static List<DataStoreInfo> findGeogitStores(Request request) {
    List<DataStoreInfo> geogitStores;

    Catalog catalog = getCatalog(request);
    org.opengis.filter.Filter filter =
        Predicates.equal("type", GeoGitDataStoreFactory.DISPLAY_NAME);
    CloseableIterator<DataStoreInfo> stores = catalog.list(DataStoreInfo.class, filter);
    try {
      Predicate<DataStoreInfo> enabled =
          new Predicate<DataStoreInfo>() {
            @Override
            public boolean apply(@Nullable DataStoreInfo input) {
              return input.isEnabled();
            }
          };
      geogitStores = ImmutableList.copyOf(Iterators.filter(stores, enabled));
    } finally {
      stores.close();
    }

    return geogitStores;
  }
  private static ImageDescriptor findImageDescriptor(TreeItemCreationTool createTool) {

    ImageDescriptor descriptor =
        DTreeViewerManager.getImageRegistry()
            .getDescriptor(DTreeViewerManager.CREATE_TREE_ITEM_IMG);
    EObject created = null;

    Iterator<CreateInstance> createInstances =
        Iterators.filter(createTool.eAllContents(), CreateInstance.class);
    while (created == null && createInstances.hasNext()) {
      CreateInstance map = createInstances.next();
      created = CreateToolItemAction.tryToInstanciateType(createTool, created, map.getTypeName());
    }

    Iterator<TreeItemMapping> it = createTool.getMapping().iterator();
    while (created == null && it.hasNext()) {
      TreeItemMapping map = it.next();
      created =
          CreateToolItemAction.tryToInstanciateType(createTool, created, map.getDomainClass());
    }

    if (created != null) {
      final IItemLabelProvider labelProvider =
          (IItemLabelProvider)
              TreeUIPlugin.getPlugin()
                  .getItemProvidersAdapterFactory()
                  .adapt(created, IItemLabelProvider.class);
      if (labelProvider != null) {
        ImageDescriptor semanticDescriptor =
            ExtendedImageRegistry.getInstance().getImageDescriptor(labelProvider.getImage(created));
        if (semanticDescriptor != null) {
          descriptor = semanticDescriptor;
        }
      }
    }

    return descriptor;
  }
Beispiel #14
0
 /**
  * Ensures that at most <code>n</code> are up and running. If less nodes that <code>n</code> are
  * running this method will not start any additional nodes.
  */
 public synchronized void ensureAtMostNumNodes(int n) {
   if (nodes.size() <= n) {
     return;
   }
   // prevent killing the master if possible
   final Iterator<NodeAndClient> values =
       n == 0
           ? nodes.values().iterator()
           : Iterators.filter(
               nodes.values().iterator(),
               Predicates.not(new MasterNodePredicate(getMasterName())));
   final Iterator<NodeAndClient> limit = Iterators.limit(values, nodes.size() - n);
   logger.info("reducing cluster size from {} to {}", nodes.size() - n, n);
   Set<NodeAndClient> nodesToRemove = new HashSet<NodeAndClient>();
   while (limit.hasNext()) {
     NodeAndClient next = limit.next();
     nodesToRemove.add(next);
     next.close();
   }
   for (NodeAndClient toRemove : nodesToRemove) {
     nodes.remove(toRemove.name);
   }
 }
Beispiel #15
0
    @Override
    protected Iterator<Calendar> iterator() {
      // wrap an iterator over services
      Iterator<Calendar> calIt =
          Iterators.transform(
              feed.services.values().iterator(),
              new Function<Service, Calendar>() {
                @Override
                public Calendar apply(Service s) {
                  return s.calendar;
                }
              });

      // not every service has a calendar (e.g. TriMet has no calendars, just calendar dates).
      // This is legal GTFS, so skip services with no calendar
      return Iterators.filter(
          calIt,
          new Predicate<Calendar>() {
            @Override
            public boolean apply(Calendar c) {
              return c != null;
            }
          });
    }
Beispiel #16
0
 /** Wraps another iterator and throws away nulls. */
 public static <T> Iterator<T> removeNull(final Iterator<T> itr) {
   return com.google.common.collect.Iterators.filter(itr, Predicates.notNull());
 }
 public Iterator<TypedVar> getDeclarativelyUnboundVarsWithoutTypes() {
   return Iterators.filter(getVars(), DECLARATIVELY_UNBOUND_VARS_WITHOUT_TYPES);
 }
Beispiel #18
0
  private static Iterator<SimpleFeature> getFeatures(
      final RevTree typeTree,
      final ObjectDatabase database,
      final ObjectId defaultMetadataId,
      final ProgressListener progressListener) {

    Iterator<NodeRef> nodes =
        new DepthTreeIterator("", defaultMetadataId, typeTree, database, Strategy.FEATURES_ONLY);

    // progress reporting
    nodes =
        Iterators.transform(
            nodes,
            new Function<NodeRef, NodeRef>() {

              private AtomicInteger count = new AtomicInteger();

              @Override
              public NodeRef apply(NodeRef input) {
                progressListener.setProgress((count.incrementAndGet() * 100.f) / typeTree.size());
                return input;
              }
            });

    Function<NodeRef, SimpleFeature> asFeature =
        new Function<NodeRef, SimpleFeature>() {

          private Map<ObjectId, FeatureBuilder> ftCache = Maps.newHashMap();

          @Override
          @Nullable
          public SimpleFeature apply(final NodeRef input) {
            final ObjectId metadataId = input.getMetadataId();
            final RevFeature revFeature = database.getFeature(input.getObjectId());

            FeatureBuilder featureBuilder = getBuilderFor(metadataId);
            Feature feature = featureBuilder.build(input.name(), revFeature);
            feature.getUserData().put(Hints.USE_PROVIDED_FID, true);
            feature.getUserData().put(RevFeature.class, revFeature);
            feature.getUserData().put(RevFeatureType.class, featureBuilder.getType());

            if (feature instanceof SimpleFeature) {
              return (SimpleFeature) feature;
            }
            return null;
          }

          private FeatureBuilder getBuilderFor(final ObjectId metadataId) {
            FeatureBuilder featureBuilder = ftCache.get(metadataId);
            if (featureBuilder == null) {
              RevFeatureType revFtype = database.getFeatureType(metadataId);
              featureBuilder = new FeatureBuilder(revFtype);
              ftCache.put(metadataId, featureBuilder);
            }
            return featureBuilder;
          }
        };

    Iterator<SimpleFeature> asFeatures = Iterators.transform(nodes, asFeature);

    UnmodifiableIterator<SimpleFeature> filterNulls =
        Iterators.filter(asFeatures, Predicates.notNull());

    return filterNulls;
  }
Beispiel #19
0
  /**
   * Executes the export operation using the parameters that have been specified.
   *
   * @return a FeatureCollection with the specified features
   */
  @Override
  protected SimpleFeatureStore _call() {
    final ObjectDatabase database = objectDatabase();
    if (filterFeatureTypeId != null) {
      RevObject filterType = database.getIfPresent(filterFeatureTypeId);
      checkArgument(
          filterType instanceof RevFeatureType, "Provided filter feature type is does not exist");
    }

    final SimpleFeatureStore targetStore = getTargetStore();

    final String refspec = resolveRefSpec();
    final String treePath = refspec.substring(refspec.indexOf(':') + 1);
    final RevTree rootTree = resolveRootTree(refspec);
    final NodeRef typeTreeRef = resolTypeTreeRef(refspec, treePath, rootTree);

    final ObjectId defaultMetadataId = typeTreeRef.getMetadataId();

    final RevTree typeTree = database.getTree(typeTreeRef.getObjectId());

    final ProgressListener progressListener = getProgressListener();

    progressListener.started();
    progressListener.setDescription(
        "Exporting from " + path + " to " + targetStore.getName().getLocalPart() + "... ");

    final Iterator<SimpleFeature> filtered;
    {
      final Iterator<SimpleFeature> plainFeatures =
          getFeatures(typeTree, database, defaultMetadataId, progressListener);

      Iterator<SimpleFeature> adaptedFeatures = adaptToArguments(plainFeatures, defaultMetadataId);

      Iterator<Optional<Feature>> transformed =
          Iterators.transform(adaptedFeatures, ExportOp.this.function);

      Iterator<SimpleFeature> result =
          Iterators.filter(
              Iterators.transform(
                  transformed,
                  new Function<Optional<Feature>, SimpleFeature>() {
                    @Override
                    public SimpleFeature apply(Optional<Feature> input) {
                      return (SimpleFeature) input.orNull();
                    }
                  }),
              Predicates.notNull());

      // check the resulting schema has something to contribute
      PeekingIterator<SimpleFeature> peekingIt = Iterators.peekingIterator(result);
      if (peekingIt.hasNext()) {
        Function<AttributeDescriptor, String> toString =
            new Function<AttributeDescriptor, String>() {
              @Override
              public String apply(AttributeDescriptor input) {
                return input.getLocalName();
              }
            };
        SimpleFeature peek = peekingIt.peek();
        Set<String> sourceAtts =
            new HashSet<String>(
                Lists.transform(peek.getFeatureType().getAttributeDescriptors(), toString));
        Set<String> targetAtts =
            new HashSet<String>(
                Lists.transform(targetStore.getSchema().getAttributeDescriptors(), toString));
        if (Sets.intersection(sourceAtts, targetAtts).isEmpty()) {
          throw new GeoToolsOpException(
              StatusCode.UNABLE_TO_ADD,
              "No common attributes between source and target feature types");
        }
      }

      filtered = peekingIt;
    }
    FeatureCollection<SimpleFeatureType, SimpleFeature> asFeatureCollection =
        new BaseFeatureCollection<SimpleFeatureType, SimpleFeature>() {

          @Override
          public FeatureIterator<SimpleFeature> features() {

            return new DelegateFeatureIterator<SimpleFeature>(filtered);
          }
        };

    // add the feature collection to the feature store
    final Transaction transaction;
    if (transactional) {
      transaction = new DefaultTransaction("create");
    } else {
      transaction = Transaction.AUTO_COMMIT;
    }
    try {
      targetStore.setTransaction(transaction);
      try {
        targetStore.addFeatures(asFeatureCollection);
        transaction.commit();
      } catch (final Exception e) {
        if (transactional) {
          transaction.rollback();
        }
        Throwables.propagateIfInstanceOf(e, GeoToolsOpException.class);
        throw new GeoToolsOpException(e, StatusCode.UNABLE_TO_ADD);
      } finally {
        transaction.close();
      }
    } catch (IOException e) {
      throw new GeoToolsOpException(e, StatusCode.UNABLE_TO_ADD);
    }

    progressListener.complete();

    return targetStore;
  }
Beispiel #20
0
 default Iterator<ClassFileResource> classFileFilteringIterator(Iterator<ClassFileResource> it) {
   return Iterators.filter(
       it, classFileResource -> classFileResource.getName().endsWith(".class"));
 }
Beispiel #21
0
        @Override
        public Iterator<TitanElement> getNew(final StandardElementQuery query) {
          Preconditions.checkArgument(
              query.getType() == StandardElementQuery.Type.VERTEX
                  || query.getType() == StandardElementQuery.Type.EDGE);
          if (query.getType() == StandardElementQuery.Type.VERTEX && hasModifications()) {
            // Collect all keys from the query - ASSUMPTION: query is an AND of KeyAtom
            final Set<TitanKey> keys = Sets.newHashSet();
            KeyAtom<TitanKey> standardIndexKey = null;
            for (KeyCondition<TitanKey> cond : query.getCondition().getChildren()) {
              KeyAtom<TitanKey> atom = (KeyAtom<TitanKey>) cond;
              if (atom.getRelation() == Cmp.EQUAL && isVertexIndexProperty(atom.getKey()))
                standardIndexKey = atom;
              keys.add(atom.getKey());
            }
            Iterator<TitanVertex> vertices;
            if (standardIndexKey == null) {
              Set<TitanVertex> vertexSet = Sets.newHashSet();
              for (TitanRelation r :
                  addedRelations.getView(
                      new Predicate<InternalRelation>() {
                        @Override
                        public boolean apply(@Nullable InternalRelation relation) {
                          return keys.contains(relation.getType());
                        }
                      })) {
                vertexSet.add(((TitanProperty) r).getVertex());
              }
              for (TitanRelation r : deletedRelations.values()) {
                if (keys.contains(r.getType())) {
                  TitanVertex v = ((TitanProperty) r).getVertex();
                  if (!v.isRemoved()) vertexSet.add(v);
                }
              }
              vertices = vertexSet.iterator();
            } else {
              vertices =
                  Iterators.transform(
                      newVertexIndexEntries
                          .get(standardIndexKey.getCondition(), standardIndexKey.getKey())
                          .iterator(),
                      new Function<TitanProperty, TitanVertex>() {
                        @Nullable
                        @Override
                        public TitanVertex apply(@Nullable TitanProperty o) {
                          return o.getVertex();
                        }
                      });
            }

            return (Iterator)
                Iterators.filter(
                    vertices,
                    new Predicate<TitanVertex>() {
                      @Override
                      public boolean apply(@Nullable TitanVertex vertex) {
                        return query.matches(vertex);
                      }
                    });
          } else if (query.getType() == StandardElementQuery.Type.EDGE
              && !addedRelations.isEmpty()) {
            return (Iterator)
                addedRelations
                    .getView(
                        new Predicate<InternalRelation>() {
                          @Override
                          public boolean apply(@Nullable InternalRelation relation) {
                            return (relation instanceof TitanEdge)
                                && !relation.isHidden()
                                && query.matches(relation);
                          }
                        })
                    .iterator();
          } else throw new IllegalArgumentException("Unexpected type: " + query.getType());
        }
Beispiel #22
0
        @Override
        public Iterator<TitanElement> execute(final StandardElementQuery query) {
          Iterator<TitanElement> iter = null;
          if (!query.hasIndex()) {
            log.warn(
                "Query requires iterating over all vertices [{}]. For better performance, use indexes",
                query.getCondition());
            if (query.getType() == StandardElementQuery.Type.VERTEX) {
              iter = (Iterator) getVertices().iterator();
            } else if (query.getType() == StandardElementQuery.Type.EDGE) {
              iter = (Iterator) getEdges().iterator();
            } else throw new IllegalArgumentException("Unexpected type: " + query.getType());
            iter =
                Iterators.filter(
                    iter,
                    new Predicate<TitanElement>() {
                      @Override
                      public boolean apply(@Nullable TitanElement element) {
                        return query.matches(element);
                      }
                    });
          } else {
            String index = query.getIndex();
            log.debug("Answering query [{}] with index {}", query, index);
            // Filter out everything not covered by the index
            KeyCondition<TitanKey> condition = query.getCondition();
            // ASSUMPTION: query is an AND of KeyAtom
            Preconditions.checkArgument(condition instanceof KeyAnd);
            Preconditions.checkArgument(condition.hasChildren());
            List<KeyCondition<TitanKey>> newConds = Lists.newArrayList();

            boolean needsFilter = false;
            for (KeyCondition<TitanKey> c : condition.getChildren()) {
              KeyAtom<TitanKey> atom = (KeyAtom<TitanKey>) c;
              if (getGraph()
                      .getIndexInformation(index)
                      .supports(atom.getKey().getDataType(), atom.getRelation())
                  && atom.getKey().hasIndex(index, query.getType().getElementType())
                  && atom.getCondition() != null) {
                newConds.add(atom);
              } else {
                log.debug(
                    "Filtered out atom [{}] from query [{}] because it is not indexed or not covered by the index");
                needsFilter = true;
              }
            }
            Preconditions.checkArgument(
                !newConds.isEmpty(), "Invalid index assignment [%s] to query [%s]", index, query);
            final StandardElementQuery indexQuery;
            if (needsFilter) {
              Preconditions.checkArgument(
                  !newConds.isEmpty(),
                  "Query has been assigned an index [%s] in error: %s",
                  query.getIndex(),
                  query);
              indexQuery =
                  new StandardElementQuery(
                      query.getType(),
                      KeyAnd.of(newConds.toArray(new KeyAtom[newConds.size()])),
                      query.getLimit(),
                      index);
            } else {
              indexQuery = query;
            }
            try {
              iter =
                  Iterators.transform(
                      indexCache
                          .get(
                              indexQuery,
                              new Callable<List<Object>>() {
                                @Override
                                public List<Object> call() throws Exception {
                                  return graph.elementQuery(indexQuery, txHandle);
                                }
                              })
                          .iterator(),
                      new Function<Object, TitanElement>() {
                        @Nullable
                        @Override
                        public TitanElement apply(@Nullable Object id) {
                          Preconditions.checkNotNull(id);
                          if (id instanceof Long) return (TitanVertex) getVertex((Long) id);
                          else if (id instanceof RelationIdentifier)
                            return (TitanElement) getEdge((RelationIdentifier) id);
                          else throw new IllegalArgumentException("Unexpected id type: " + id);
                        }
                      });
            } catch (Exception e) {
              throw new TitanException("Could not call index", e);
            }
            if (needsFilter) {
              iter =
                  Iterators.filter(
                      iter,
                      new Predicate<TitanElement>() {
                        @Override
                        public boolean apply(@Nullable TitanElement element) {
                          return element != null
                              && !element.isRemoved()
                              && !isDeleted(query, element)
                              && query.matches(element);
                        }
                      });
            } else {
              iter =
                  Iterators.filter(
                      iter,
                      new Predicate<TitanElement>() {
                        @Override
                        public boolean apply(@Nullable TitanElement element) {
                          return element != null
                              && !element.isRemoved()
                              && !isDeleted(query, element);
                        }
                      });
            }
          }
          return iter;
        }
Beispiel #23
0
 @Override
 public Iterator<E> iterator() {
   return Iterators.filter(unfiltered.iterator(), predicate);
 }
 @Override
 public Iterator<E> getEdges(Predicate<? super E> filter) {
   return Iterators.filter(getEdges(), filter);
 }
 @Override
 public Iterator<V> getVertices(Predicate<? super V> filter) {
   return Iterators.filter(getVertices(), filter);
 }
 @Override
 public Iterator<E> getOutEdges(V vertex, Predicate<? super E> filter) {
   return Iterators.filter(getOutEdges(vertex), filter);
 }
 public Iterator iterator() {
   return Iterators.filter(this.field_148748_b.iterator(), Predicates.notNull());
 }
Beispiel #28
0
 @Override
 public Maybe<JsonElement> apply(JsonElement input) {
   JsonArray array = input.getAsJsonArray();
   Iterator<JsonElement> filtered = Iterators.filter(array.iterator(), predicate);
   return Maybe.next(filtered);
 }
 @Override
 @Deprecated
 public Iterator<E> iterator() {
   return limit(Iterators.filter(delegate.iterator(), predicate));
 }