public boolean shouldCascadeAllParts() { return getCascadeDepth() == CascadeAllParts; }
/** * This is the root method called to start the iteration. */ public void startIterationOn(Object sourceObject) { if (getVisitedObjects().containsKey(sourceObject)) { return; } getVisitedObjects().put(sourceObject, sourceObject); setCurrentMapping(null); setCurrentDescriptor(getSession().getDescriptor(sourceObject)); iterate(sourceObject); // start the recursion if ((getCurrentDescriptor() != null) && (!shouldCascadeNoParts()) && !this.shouldBreak()) { iterateReferenceObjects(sourceObject); } }
/** * INTERNAL: * Iterate on the appropriate attribute. */ @Override public void iterate(DescriptorIterator iterator) { // PERF: Only iterate when required. if (iterator.shouldIterateOnPrimitives()) { iterator.iteratePrimitiveForMapping(getAttributeValueFromObject(iterator.getVisitedParent()), this); } }
/** * Iterate on the primitive value for its mapping. */ public void iteratePrimitiveForMapping(Object primitiveValue, DatabaseMapping mapping) { if (primitiveValue == null) { return; } setCurrentMapping(mapping); setCurrentDescriptor(null); if (shouldIterateOnPrimitives()) {// false by default internalIteratePrimitive(primitiveValue); } }
/** * Iterate on the mapping's reference object and * recursively iterate on the reference object's * reference objects. * This is used for aggregate and aggregate collection mappings, which are not iterated on by default. */ public void iterateForAggregateMapping(Object aggregateObject, DatabaseMapping mapping, ClassDescriptor descriptor) { if (aggregateObject == null) { return; } setCurrentMapping(mapping); // aggregate descriptors are passed in because they could be part of an inheritance tree setCurrentDescriptor(descriptor); if (shouldIterateOnAggregates()) {// false by default internalIterateAggregateObject(aggregateObject); if (shouldBreak()) { setShouldBreak(false); return; } } iterateReferenceObjects(aggregateObject); }
if ((!shouldIterateOverWrappedObjects()) && (rd != null) && (rd.hasWrapperPolicy())) { return; if (getVisitedObjects().containsKey(referenceObject)) { return; getVisitedObjects().put(referenceObject, referenceObject); setCurrentMapping(mapping); setCurrentDescriptor(getDescriptorFor(referenceObject)); internalIterateReferenceObject(referenceObject); if (shouldBreak()) { setShouldBreak(false); return; iterateReferenceObjects(referenceObject);
/** * Iterate on the indirection object for its mapping. */ public void iterateIndirectContainerForMapping(IndirectContainer container, DatabaseMapping mapping) { setCurrentMapping(mapping); setCurrentDescriptor(null); if (shouldIterateOnIndirectionObjects()) {// false by default internalIterateIndirectContainer(container); } if (shouldIterateOverUninstantiatedIndirectionObjects() || (shouldIterateOverIndirectionObjects() && container.isInstantiated())) { // force instantiation only if specified mapping.iterateOnRealAttributeValue(this, container); } else if (shouldIterateOverIndirectionObjects()) { // PERF: Allow the indirect container to iterate any cached elements. if (container instanceof IndirectCollection) { mapping.iterateOnRealAttributeValue(this, ((IndirectCollection)container).getAddedElements()); } } }
/** * INTERNAL: * Iterate on the appropriate attribute value. */ public void iterate(DescriptorIterator iterator) { // PERF: Only iterate when required. if (iterator.shouldIterateOnPrimitives()) { Object attributeValue = this.getAttributeValueFromObject(iterator.getVisitedParent()); if (attributeValue == null) { return; } ContainerPolicy cp = this.getContainerPolicy(); for (Object iter = cp.iteratorFor(attributeValue); cp.hasNext(iter);) { iterator.iteratePrimitiveForMapping(cp.next(iter, iterator.getSession()), this); } } }
/** * Iterate on the specified attribute value. */ protected void iterateOnAttributeValue(DescriptorIterator iterator, Object attributeValue) { iterator.iterateForAggregateMapping(attributeValue, this, getReferenceDescriptor(attributeValue, iterator.getSession())); }
protected void internalIterateReferenceObjects(Object sourceObject) { List<DatabaseMapping> mappings; if (shouldIterateOnPrimitives()) { mappings = getCurrentDescriptor().getObjectBuilder().getDescriptor().getMappings(); } else { ObjectBuilder builder = getCurrentDescriptor().getObjectBuilder().getDescriptor().getObjectBuilder(); if (shouldIterateOnFetchGroupAttributesOnly()) { if(getCurrentDescriptor().hasFetchGroupManager()) { FetchGroup fetchGroup = getCurrentDescriptor().getFetchGroupManager().getObjectFetchGroup(sourceObject); if (fetchGroup != null) { List<DatabaseMapping> fetchGroupMappings = new ArrayList();
/** * Fetch and return the descriptor for the specified object. */ protected ClassDescriptor getDescriptorFor(Object object) { ClassDescriptor result = getSession().getDescriptor(object); if (result == null) { throw DescriptorException.missingDescriptor(object.getClass().getName()); } return result; }
/** * INTERNAL: * Iterate on the attribute value. * The value holder has already been processed. */ @Override public void iterateOnRealAttributeValue(DescriptorIterator iterator, Object realAttributeValue) { // This may be wrapped as the caller in iterate on foreign reference does not unwrap as the type is generic. Object unwrappedAttributeValue = getReferenceDescriptor().getObjectBuilder().unwrapObject(realAttributeValue, iterator.getSession()); iterator.iterateReferenceObjectForMapping(unwrappedAttributeValue, this); }
/** * INTERNAL: * Iterate on the attribute value. * The value holder has already been processed. * PERF: Avoid iteration if not required. */ public void iterateOnRealAttributeValue(DescriptorIterator iterator, Object realAttributeValue) { super.iterateOnRealAttributeValue(iterator, realAttributeValue); ContainerPolicy cp = getContainerPolicy(); if (realAttributeValue != null && !iterator.shouldIterateOnPrimitives()) { for (Object iter = cp.iteratorFor(realAttributeValue); cp.hasNext(iter);) { Object wrappedObject = cp.nextEntry(iter, iterator.getSession()); cp.iterateOnMapKey(iterator, wrappedObject); } } }
/** * INTERNAL: * Perform the iteration opperation on the iterators current objects attributes. * Only require if primitives are desired. */ @Override public void iterate(DescriptorIterator iterator) { Object attributeValue = getAttributeValueFromObject(iterator.getVisitedParent()); this.indirectionPolicy.iterateOnAttributeValue(iterator, attributeValue); }
/** * Iterate over the sourceObject's reference objects, * updating the visited stack appropriately. */ protected void iterateReferenceObjects(Object sourceObject) { getVisitedStack().push(sourceObject); getCurrentDescriptor().getObjectBuilder().iterate(this); getVisitedStack().pop(); }
/** * Return the second-to-last object visited. */ public Object getVisitedGrandparent() { Object parent = getVisitedStack().pop(); Object result = getVisitedStack().peek(); getVisitedStack().push(parent); return result; }
/** * Iterate over the sourceObject's reference objects, * updating the visited stack appropriately. */ protected void iterateReferenceObjects(Object sourceObject) { if(this.usesGroup) { // object is outside of the group - don't iterate over its references if(this.currentGroup == null || !this.currentGroup.hasItems()) { return; } } getVisitedStack().push(sourceObject); internalIterateReferenceObjects(sourceObject); getVisitedStack().pop(); }
if ((!shouldIterateOverWrappedObjects()) && (rd != null) && (rd.hasWrapperPolicy())) { return; Set visited = (Set)getVisitedObjects().get(referenceObject); if(visited == null) { visited = new HashSet(1); visited.add(this.currentItem.getGroup()); getVisitedObjects().put(referenceObject, visited); } else { if(visited.contains(this.currentItem.getGroup())) { if (getVisitedObjects().containsKey(referenceObject)) { return; getVisitedObjects().put(referenceObject, referenceObject); setCurrentMapping(mapping); setCurrentDescriptor(getDescriptorFor(referenceObject)); internalIterateReferenceObject(referenceObject); if (shouldBreak()) { setShouldBreak(false); if(this.usesGroup) { this.currentGroup = currentGroupOriginal; iterateReferenceObjects(referenceObject); if(this.usesGroup) { this.currentGroup = currentGroupOriginal;
return; setCurrentMapping(mapping); setCurrentDescriptor(descriptor); if (shouldIterateOnAggregates()) {// false by default internalIterateAggregateObject(aggregateObject); if (shouldBreak()) { setShouldBreak(false); if(this.usesGroup) { this.currentGroup = currentGroupOriginal; iterateReferenceObjects(aggregateObject); if(this.usesGroup) { this.currentGroup = currentGroupOriginal;
/** * Iterate on the indirection object for its mapping. */ public void iterateIndirectContainerForMapping(IndirectContainer container, DatabaseMapping mapping) { setCurrentMapping(mapping); setCurrentDescriptor(null); if (shouldIterateOnIndirectionObjects()) {// false by default internalIterateIndirectContainer(container); } if (shouldIterateOverUninstantiatedIndirectionObjects() || (shouldIterateOverIndirectionObjects() && container.isInstantiated())) { // force instantiation only if specified mapping.iterateOnRealAttributeValue(this, container); } else if (shouldIterateOverIndirectionObjects()) { // PERF: Allow the indirect container to iterate any cached elements. if (container instanceof IndirectCollection) { mapping.iterateOnRealAttributeValue(this, ((IndirectCollection)container).getAddedElements()); } } }