public Constraints constraints() {
synchronized (streamLock()) {
Constraint[] constraints = new Constraint[i_constraints.size()];
i_constraints.toArray(constraints);
return new QConstraints(_trans, constraints);
}
}
public void run(STClass[] classes, STEngine[] engines, boolean a_quiet) {
begin();
setSodaTestOn(classes);
for (int i = 0; i < engines.length; i++) {
engine = engines[i];
engine.reset();
engine.open();
store(classes);
engine.commit();
engine.close();
engine.open();
test(classes);
engine.close();
engine.reset();
}
if (failedTestClasses.size() > 0) {
System.err.println("\nFailed test classes:\n");
Iterator4 i = failedTestClasses.iterator();
while (i.moveNext()) {
System.err.println(i.current().getClass().getName());
}
System.err.println("\n");
}
}
private Collection4 fieldPathFromTop() {
QQueryBase q = this;
final Collection4 fieldPath = new Collection4();
while (q.i_parent != null) {
fieldPath.prepend(q.i_field);
q = q.i_parent;
}
return fieldPath;
}
Constraint toConstraint(final Collection4 constraints) {
if (constraints.size() == 1) {
return (Constraint) constraints.singleElement();
} else if (constraints.size() > 0) {
Constraint[] constraintArray = new Constraint[constraints.size()];
constraints.toArray(constraintArray);
return new QConstraints(_trans, constraintArray);
}
return null;
}
public void error(String msg) {
if (!failedTestClasses.contains(currentTestClass)) {
failedTestClasses.add(currentTestClass);
}
if (!quiet) {
System.err.println(msg);
new ExpectationFailed().printStackTrace();
System.err.println();
}
}
private Constraint addEvaluationToAllConstraints(QConEvaluation eval) {
if (i_constraints.size() == 0) {
_trans
.container()
.classCollection()
.iterateTopLevelClasses(
new Visitor4() {
public void visit(Object obj) {
ClassMetadata classMetadata = (ClassMetadata) obj;
QConClass qcc = new QConClass(_trans, classMetadata.classReflector());
addConstraint(qcc);
toConstraint(i_constraints).or(qcc);
}
});
}
Iterator4 i = iterateConstraints();
while (i.moveNext()) {
((QCon) i.current()).addConstraint(eval);
}
// FIXME: should return valid Constraint object
return null;
}
private Collection4 introduceClassConstrain(ReflectClass claxx) {
final Collection4 newConstraints = new Collection4();
final Iterator4 existingConstraints = iterateConstraints();
while (existingConstraints.moveNext()) {
final QCon existingConstraint = (QConObject) existingConstraints.current();
final BooleanByRef removeExisting = new BooleanByRef(false);
final QCon newConstraint = existingConstraint.shareParentForClass(claxx, removeExisting);
if (newConstraint != null) {
newConstraints.add(newConstraint);
addConstraint(newConstraint);
if (removeExisting.value) {
removeConstraint(existingConstraint);
}
}
}
return newConstraints;
}
private Constraint addClassConstraint(ReflectClass claxx) {
if (isTheObjectClass(claxx)) {
return null;
}
if (claxx.isInterface()) {
return addInterfaceConstraint(claxx);
}
final Collection4 newConstraints = introduceClassConstrain(claxx);
if (newConstraints.isEmpty()) {
QConClass qcc = new QConClass(_trans, claxx);
addConstraint(qcc);
return qcc;
}
return toConstraint(newConstraints);
}
private QConClass classConstraint() {
if (i_constraints.size() != 1) {
return null;
}
Constraint constr = singleConstraint();
if (constr.getClass() != QConClass.class) {
return null;
}
return (QConClass) constr;
}
private void addConstraint(Collection4 col, Object obj) {
if (attachToExistingConstraints(col, obj, true)) {
return;
}
if (attachToExistingConstraints(col, obj, false)) {
return;
}
QConObject newConstraint = new QConObject(_trans, null, null, obj);
addConstraint(newConstraint);
col.add(newConstraint);
}
public Iterator4 executeSnapshot() {
final CreateCandidateCollectionResult r = createCandidateCollection();
final Collection4 executionPath = executionPath(r);
Iterator4 candidatesIterator = new Iterator4Impl(r.candidateCollection);
Collection4 snapshots = new Collection4();
while (candidatesIterator.moveNext()) {
QCandidates candidates = (QCandidates) candidatesIterator.current();
snapshots.add(candidates.executeSnapshot(executionPath));
}
Iterator4 snapshotsIterator = snapshots.iterator();
final CompositeIterator4 resultingIDs = new CompositeIterator4(snapshotsIterator);
if (!r.checkDuplicates) {
return resultingIDs;
}
return checkDuplicates(resultingIDs);
}
public QueryResult getQueryResult() {
synchronized (streamLock()) {
if (i_constraints.size() == 0) {
return executeAllObjectsQuery();
}
QueryResult result = executeClassOnlyQuery();
if (result != null) {
return result;
}
optimizeJoins();
return executeQuery();
}
}
private Constraint addInterfaceConstraint(ReflectClass claxx) {
Collection4 classes = stream().classCollection().forInterface(claxx);
if (classes.size() == 0) {
QConClass qcc = new QConClass(_trans, null, null, claxx);
addConstraint(qcc);
return qcc;
}
Iterator4 i = classes.iterator();
Constraint constr = null;
while (i.moveNext()) {
ClassMetadata classMetadata = (ClassMetadata) i.current();
ReflectClass classMetadataClaxx = classMetadata.classReflector();
if (classMetadataClaxx != null) {
if (!classMetadataClaxx.isInterface()) {
if (constr == null) {
constr = constrain(classMetadataClaxx);
} else {
constr = constr.or(constrain(classMetadata.classReflector()));
}
}
}
}
return constr;
}
private boolean attachToExistingConstraints(
Collection4 newConstraintsCollector, Object obj, boolean onlyForPaths) {
boolean found = false;
final Iterator4 j = iterateConstraints();
while (j.moveNext()) {
QCon existingConstraint = (QCon) j.current();
final BooleanByRef removeExisting = new BooleanByRef(false);
if (!onlyForPaths || (existingConstraint instanceof QConPath)) {
QCon newConstraint = existingConstraint.shareParent(obj, removeExisting);
if (newConstraint != null) {
newConstraintsCollector.add(newConstraint);
addConstraint(newConstraint);
if (removeExisting.value) {
removeConstraint(existingConstraint);
}
found = true;
if (!onlyForPaths) {
break;
}
}
}
}
return found;
}
void addConstraint(QCon a_constraint) {
i_constraints.add(a_constraint);
}
void removeConstraint(QCon a_constraint) {
i_constraints.remove(a_constraint);
}
private boolean descend1(final QQuery query, final String fieldName, IntByRef run) {
if (run.value == 2 || i_constraints.size() == 0) {
// On the second run we are really creating a second independant
// query network that is not joined to other higher level
// constraints.
// Let's see how this works out. We may need to join networks.
run.value = 0; // prevent a double run of this code
stream()
.classCollection()
.attachQueryNode(
fieldName,
new Visitor4() {
boolean untypedFieldConstraintCollected = false;
public void visit(Object obj) {
Object[] pair = ((Object[]) obj);
ClassMetadata containingClass = (ClassMetadata) pair[0];
FieldMetadata field = (FieldMetadata) pair[1];
if (isTyped(field)) {
addFieldConstraint(containingClass, field);
return;
}
if (untypedFieldConstraintCollected) return;
addFieldConstraint(containingClass, field);
untypedFieldConstraintCollected = true;
}
private boolean isTyped(FieldMetadata field) {
return !Handlers4.isUntyped(field.getHandler());
}
private void addFieldConstraint(
ClassMetadata containingClass, FieldMetadata field) {
QConClass qcc =
new QConClass(
_trans, null, field.qField(_trans), containingClass.classReflector());
addConstraint(qcc);
toConstraint(i_constraints).or(qcc);
}
});
}
checkConstraintsEvaluationMode();
final BooleanByRef foundClass = new BooleanByRef(false);
Iterator4 i = iterateConstraints();
while (i.moveNext()) {
if (((QCon) i.current()).attach(query, fieldName)) {
foundClass.value = true;
}
}
return foundClass.value;
}
public static int failedClassesSize() {
return failedTestClasses.size();
}
private Constraint singleConstraint() {
return (Constraint) i_constraints.singleElement();
}