@Override protected NodeBooleanQuery getTopLevelQuery(final NodeQuery query) { NodeBooleanQuery q = new NodeBooleanQuery(); // set level and node constraints q.setLevelConstraint(query.getLevelConstraint()); q.setNodeConstraint(query.getNodeConstraint()[0], query.getNodeConstraint()[1]); // set ancestor q.setAncestorPointer(query.ancestor); return q; }
@Override public int hashCode() { final int prime = 31; int result = super.hashCode(); result = prime * result + Float.floatToIntBits(this.getBoost()); result = prime * result + q.hashCode(); result = prime * result + lowerBound; result = prime * result + upperBound; result = prime * result + levelConstraint; return result; }
public synchronized ResolutionContext startResolvingChildren(BOMNode node) throws CoreException { Resolution nodeRes = node.getResolution(); if (invalidateRun || nodeRes == null) return null; ComponentQuery cquery = node.getQuery(); ResolutionContext originalContext = query.getResolutionContext(); ResolutionContext context = originalContext; if (!(cquery == null || cquery.equals(context.getComponentQuery()))) context = new ResolutionContext(cquery, context); CSpec cspec = nodeRes.getCSpec(); Collection<Generator> generators = cspec.getGeneratorList(); if (generators.size() > 0) { if (context == originalContext) context = new ResolutionContext(originalContext.getComponentQuery(), originalContext); context.setGenerators(cspec, generators); } if (context != originalContext) query = context.getNodeQuery(query.getQualifiedDependency()); return context; }
/** * A real node-function (using the node argument). Returns the next newer node of same type. Also * a nice example on the difference between core and bridge. */ public Object successor() { if (node == null) throw new IllegalArgumentException("successor is a node-function"); if (cloud != null) { log.debug("Using bridge (security restrictions will be honoured)"); NodeManager nm = node.getNodeManager(); NodeQuery q = nm.createQuery(); StepField field = q.getStepField(nm.getField("number")); q.setConstraint( q.createConstraint( field, FieldCompareConstraint.GREATER, Integer.valueOf(node.getNumber()))); q.addSortOrder(field, SortOrder.ORDER_ASCENDING); q.setMaxNumber(1); NodeIterator i = nm.getList(q).nodeIterator(); return i.hasNext() ? i.nextNode() : null; } else { log.debug("Using core."); throw new UnsupportedOperationException("Core implementation was dropped. See source code."); /* This is how it would go with core objects MMObjectBuilder builder = MMBase.getMMBase().getBuilder(node.getNodeManager().getName()); NodeSearchQuery query = new NodeSearchQuery(builder); StepField field = query.getField(builder.getField("number")); BasicFieldValueConstraint cons = new BasicFieldValueConstraint(field, node.getNumber()); cons.setOperator(FieldCompareConstraint.GREATER); query.setConstraint(cons); query.addSortOrder(field); query.setMaxNumber(1); try { java.util.Iterator<MMObjectNode> i = builder.getNodes(query).iterator(); return i.hasNext() ? i.next() : null; } catch (Exception e) { return null; } */ } }
@Override public Query rewrite(final IndexReader reader, final MultiNodeTermQuery query) throws IOException { // Disabled cutoffs final int docCountCutoff = Integer.MAX_VALUE; final int termCountLimit = Integer.MAX_VALUE; final CutOffTermCollector col = new CutOffTermCollector(docCountCutoff, termCountLimit); this.collectTerms(reader, query, col); final int size = col.pendingTerms.size(); if (col.hasCutOff) { return MultiNodeTermQuery.CONSTANT_SCORE_FILTER_REWRITE.rewrite(reader, query); } else if (size == 0) { return this.getTopLevelQuery(query); } else { final NodeBooleanQuery bq = this.getTopLevelQuery(query); final BytesRefHash pendingTerms = col.pendingTerms; final int sort[] = pendingTerms.sort(col.termsEnum.getComparator()); for (int i = 0; i < size; i++) { final int pos = sort[i]; // docFreq is not used for constant score here, we pass 1 // to explicitely set a fake value, so it's not calculated this.addClause( bq, new Term(query.field, pendingTerms.get(pos, new BytesRef())), 1, 1.0f, col.array.termState[pos]); } // Strip scores final NodeQuery result = new NodeConstantScoreQuery(bq); result.setBoost(query.getBoost()); return result; } }
public synchronized void addDependencyQualification(QualifiedDependency newQDep, String tagInf) throws CoreException { NodeQuery qualifiedQuery = query.addDependencyQualification(newQDep); if (qualifiedQuery == query) // // Old query already declared the needed purposes. // return; VersionRange newVd = qualifiedQuery.getVersionRange(); if (resolution != null) { // Re-resolve might be necessary // if ((newVd == null || newVd.isIncluded(resolution.getVersion())) && query .getQualifiedDependency() .hasAllAttributes(qualifiedQuery.getRequiredAttributes())) { // Nope, the resolution is still valid for this new query // query = qualifiedQuery; if (tagInfo != null) qualifiedQuery.getContext().addTagInfo(qualifiedQuery.getComponentRequest(), tagInf); return; } } // New version constraints or new attributes were introduced that // invalidated the // current resolution. We need to invalidate what we have and make sure // its done // again. // resolution = null; children = noChildren; query = qualifiedQuery; invalidateRun = true; if (tagInfo != null) qualifiedQuery.getContext().addTagInfo(qualifiedQuery.getComponentRequest(), tagInf); }
public ResolverNode(NodeQuery query, String tagInfo) { this.query = query; this.children = noChildren; this.tagInfo = tagInfo; if (tagInfo != null) query.getContext().addTagInfo(query.getComponentRequest(), tagInfo); }
public BOMNode collectNodes( Map<UUID, BOMNode> nodeMap, Stack<Resolution> circularDepTrap, boolean sameTop) throws CoreException { if (query.skipComponent()) return null; if (generatorNode != null) return generatorNode; if (resolution == null) return new UnresolvedNode(query.getQualifiedDependency()); UUID myID = resolution.getId(); BOMNode node = nodeMap.get(myID); if (node != null) return node; if (circularDepTrap.contains(resolution)) { if (query.allowCircularDependency()) return null; ArrayList<String> attrs = new ArrayList<String>(circularDepTrap.size()); for (Resolution res : circularDepTrap) attrs.add(res.getCSpec().getName()); attrs.add(resolution.getName()); throw new CircularDependencyException(attrs); } boolean transitive = true; if (IComponentType.OSGI_BUNDLE.equals(resolution.getComponentTypeId())) { // We don't traverse the children of source bundles since that // dependency is synthesized transitive = !resolution.getName().endsWith(".source"); // $NON-NLS-1$ } List<BOMNode> childNodes; int top = children.length; ComponentQuery cquery = query.getComponentQuery(); if (transitive && top > 0) { try { ArrayList<BOMNode> childNodeArr = new ArrayList<BOMNode>(top); circularDepTrap.push(resolution); for (ResolverNode child : children) { boolean sameChildTop = cquery.equals(child.query.getComponentQuery()); BOMNode childNode = child.collectNodes(nodeMap, circularDepTrap, sameChildTop); if (childNode == null) { // We encountered a skipped component or an allowed // circular dependency. This // means we must alter the resolution of this node // String depName = child.getQuery().getComponentRequest().getName(); CSpec cspec = resolution.getCSpec(); CSpecBuilder bld = new CSpecBuilder(); bld.initFrom(cspec); for (IAttribute attr : cspec.getAttributes().values()) { for (IPrerequisite pq : attr.getPrerequisites()) { if (depName.equals(pq.getComponentName())) ((TopLevelAttributeBuilder) bld.getAttribute(attr.getName())) .removePrerequisite(pq); } } bld.removeDependency(depName); cspec = bld.createCSpec(); resolution = new Resolution(cspec, resolution); } else childNodeArr.add(childNode); } circularDepTrap.pop(); childNodes = childNodeArr; } catch (CircularDependencyException e) { if (query.allowCircularDependency()) return null; throw e; } } else childNodes = Collections.emptyList(); node = new ResolvedNode(resolution, childNodes); if (!sameTop) node = BillOfMaterials.create(node, cquery); nodeMap.put(myID, node); return node; }
@Override public String toString(final String field) { return q.toString(); }