예제 #1
0
  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;
  }
예제 #2
0
 public void unmarshall(final Transaction a_trans) {
   _evaluationMode = QueryEvaluationMode.fromInt(_evaluationModeAsInt);
   _trans = a_trans;
   Iterator4 i = iterateConstraints();
   while (i.moveNext()) {
     ((QCon) i.current()).unmarshall(a_trans);
   }
 }
예제 #3
0
 private void logConstraints() {
   if (Debug4.queries) {
     Iterator4 i = iterateConstraints();
     while (i.moveNext()) {
       ((QCon) i.current()).log("");
     }
   }
 }
예제 #4
0
  public void marshall() {
    checkConstraintsEvaluationMode();

    _evaluationModeAsInt = _evaluationMode.asInt();
    Iterator4 i = iterateConstraints();
    while (i.moveNext()) {
      ((QCon) i.current()).getRoot().marshall();
    }
  }
예제 #5
0
 private boolean constraintCanBeAddedToExisting(List4 candidatesList, QCon constraint) {
   Iterator4 j = new Iterator4Impl(candidatesList);
   while (j.moveNext()) {
     QCandidates candidates = (QCandidates) j.current();
     if (candidates.fitsIntoExistingConstraintHierarchy(constraint)) {
       return true;
     }
   }
   return false;
 }
예제 #6
0
 private void addConstraintToCandidatesList(List4 candidatesList, QCon qcon) {
   if (candidatesList == null) {
     return;
   }
   Iterator4 j = new Iterator4Impl(candidatesList);
   while (j.moveNext()) {
     QCandidates candidates = (QCandidates) j.current();
     candidates.addConstraint(qcon);
   }
 }
예제 #7
0
 public String toString() {
   StringBuffer sb = new StringBuffer();
   sb.append("QQueryBase\n");
   Iterator4 i = iterateConstraints();
   while (i.moveNext()) {
     QCon constraint = (QCon) i.current();
     sb.append(constraint);
     sb.append("\n");
   }
   return sb.toString();
 }
예제 #8
0
 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 static ReflectConstructorSpec findConstructor(
      final ReflectClass claxx, Tree sortedConstructors) {
    if (sortedConstructors == null) {
      return ReflectConstructorSpec.INVALID_CONSTRUCTOR;
    }

    Iterator4 iter = new TreeNodeIterator(sortedConstructors);
    while (iter.moveNext()) {
      Object current = iter.current();
      ReflectConstructor constructor = (ReflectConstructor) ((TreeIntObject) current)._object;
      Object[] args = nullArgumentsFor(constructor);
      Object res = constructor.newInstance(args);
      if (res != null) {
        return new ReflectConstructorSpec(constructor, args);
      }
    }
    return ReflectConstructorSpec.INVALID_CONSTRUCTOR;
  }
예제 #10
0
 private List4 createQCandidatesList() {
   List4 candidatesList = null;
   Iterator4 i = iterateConstraints();
   while (i.moveNext()) {
     QCon constraint = (QCon) i.current();
     constraint = constraint.getRoot();
     ClassMetadata classMetadata = constraint.getYapClass();
     if (classMetadata == null) {
       continue;
     }
     if (constraintCanBeAddedToExisting(candidatesList, constraint)) {
       continue;
     }
     QCandidates candidates = new QCandidates((LocalTransaction) _trans, classMetadata, null);
     candidatesList = new List4(candidatesList, candidates);
   }
   return candidatesList;
 }
예제 #11
0
 public CreateCandidateCollectionResult createCandidateCollection() {
   List4 candidatesList = createQCandidatesList();
   boolean checkDuplicates = false;
   boolean topLevel = true;
   Iterator4 i = iterateConstraints();
   while (i.moveNext()) {
     QCon constraint = (QCon) i.current();
     QCon old = constraint;
     constraint = constraint.getRoot();
     if (constraint != old) {
       checkDuplicates = true;
       topLevel = false;
     }
     ClassMetadata classMetadata = constraint.getYapClass();
     if (classMetadata == null) {
       break;
     }
     addConstraintToCandidatesList(candidatesList, constraint);
   }
   return new CreateCandidateCollectionResult(candidatesList, checkDuplicates, topLevel);
 }
예제 #12
0
  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);
  }
예제 #13
0
 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;
 }
예제 #14
0
 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;
 }
예제 #15
0
  // Our QConPath objects are just placeholders to fields,
  // so the parents are reachable.
  // If we find a "real" constraint, we throw the QPath
  // out and replace it with the other constraint.
  private void morph(BooleanByRef removeExisting, QCon newConstraint, ReflectClass claxx) {
    boolean mayMorph = true;
    if (claxx != null) {
      ClassMetadata yc = i_trans.container().produceClassMetadata(claxx);
      if (yc != null) {
        Iterator4 i = iterateChildren();
        while (i.moveNext()) {
          QField qf = ((QCon) i.current()).getField();
          if (!yc.hasField(i_trans.container(), qf.name())) {
            mayMorph = false;
            break;
          }
        }
      }
    }

    if (mayMorph) {
      Iterator4 j = iterateChildren();
      while (j.moveNext()) {
        newConstraint.addConstraint((QCon) j.current());
      }
      if (hasJoins()) {
        Iterator4 k = iterateJoins();
        while (k.moveNext()) {
          QConJoin qcj = (QConJoin) k.current();
          qcj.exchangeConstraint(this, newConstraint);
          newConstraint.addJoin(qcj);
        }
      }
      i_parent.exchangeConstraint(this, newConstraint);
      removeExisting.value = true;

    } else {
      i_parent.addConstraint(newConstraint);
    }
  }
예제 #16
0
  private boolean forEachConstraintRecursively(Function4 block) {
    Queue4 queue = new NoDuplicatesQueue(new NonblockingQueue());
    Iterator4 constrIter = iterateConstraints();
    while (constrIter.moveNext()) {
      queue.add(constrIter.current());
    }
    while (queue.hasNext()) {
      QCon constr = (QCon) queue.next();
      Boolean cancel = (Boolean) block.apply(constr);
      if (cancel.booleanValue()) {
        return true;
      }

      Iterator4 childIter = constr.iterateChildren();
      while (childIter.moveNext()) {
        queue.add(childIter.current());
      }
      Iterator4 joinIter = constr.iterateJoins();
      while (joinIter.moveNext()) {
        queue.add(joinIter.current());
      }
    }
    return false;
  }
 public boolean moveNext() {
   if (_delegate != null) {
     if (_delegate.moveNext()) {
       return true;
     }
     _delegate = null;
   }
   _currentElement++;
   if (_currentElement >= _array.length) {
     return false;
   }
   Object obj = _array[_currentElement];
   Class clazz = obj.getClass();
   if (clazz.isArray()) {
     if (clazz.getComponentType().isArray()) {
       _delegate = new MultidimensionalArrayIterator(_reflectArray, (Object[]) obj);
     } else {
       _delegate = new ReflectArrayIterator(_reflectArray, obj);
     }
     return moveNext();
   }
   return true;
 }
 public Object current() {
   if (_delegate == null) {
     return _array[_currentElement];
   }
   return _delegate.current();
 }
예제 #19
0
  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;
  }
예제 #20
0
  public void executeLocal(final IdListQueryResult result) {
    checkConstraintsEvaluationMode();

    CreateCandidateCollectionResult r = createCandidateCollection();

    boolean checkDuplicates = r.checkDuplicates;
    boolean topLevel = r.topLevel;
    List4 candidateCollection = r.candidateCollection;

    if (Debug4.queries) {
      logConstraints();
    }

    if (candidateCollection != null) {

      final Collection4 executionPath = topLevel ? null : fieldPathFromTop();

      Iterator4 i = new Iterator4Impl(candidateCollection);
      while (i.moveNext()) {
        ((QCandidates) i.current()).execute();
      }

      if (candidateCollection._next != null) {
        checkDuplicates = true;
      }

      if (checkDuplicates) {
        result.checkDuplicates();
      }

      final ObjectContainerBase stream = stream();
      i = new Iterator4Impl(candidateCollection);
      while (i.moveNext()) {
        QCandidates candidates = (QCandidates) i.current();
        if (topLevel) {
          candidates.traverse(result);
        } else {
          candidates.traverse(
              new Visitor4() {
                public void visit(Object a_object) {
                  QCandidate candidate = (QCandidate) a_object;
                  if (candidate.include()) {
                    TreeInt ids = new TreeInt(candidate._key);
                    final ByRef<TreeInt> idsNew = new ByRef<TreeInt>();
                    Iterator4 itPath = executionPath.iterator();
                    while (itPath.moveNext()) {
                      idsNew.value = null;
                      final String fieldName = (String) (itPath.current());
                      if (ids != null) {
                        ids.traverse(
                            new Visitor4() {
                              public void visit(Object treeInt) {
                                int id = ((TreeInt) treeInt)._key;
                                StatefulBuffer reader = stream.readStatefulBufferById(_trans, id);
                                if (reader != null) {
                                  ObjectHeader oh = new ObjectHeader(stream, reader);
                                  CollectIdContext context =
                                      new CollectIdContext(_trans, oh, reader);
                                  oh.classMetadata().collectIDs(context, fieldName);
                                  Tree.traverse(
                                      context.ids(),
                                      new Visitor4<TreeInt>() {
                                        public void visit(TreeInt node) {
                                          idsNew.value = TreeInt.add(idsNew.value, node._key);
                                        }
                                      });
                                }
                              }
                            });
                      }
                      ids = (TreeInt) idsNew.value;
                    }
                    if (ids != null) {
                      ids.traverse(
                          new Visitor4() {
                            public void visit(Object treeInt) {
                              result.addKeyCheckDuplicates(((TreeInt) treeInt)._key);
                            }
                          });
                    }
                  }
                }
              });
        }
      }
    }
    sort(result);
  }
예제 #21
0
 public void checkConstraintsEvaluationMode() {
   Iterator4 constraints = iterateConstraints();
   while (constraints.moveNext()) {
     ((QConObject) constraints.current()).setEvaluationMode();
   }
 }