@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();
}
