/** Compare the attributes. Return true if they are alike. Ignore the order of the elements. */
  private boolean compareAttributeValuesWithoutOrder(
      Object collection1, Object collection2, AbstractSession session) {
    ContainerPolicy cp = this.getContainerPolicy();

    Vector vector2 = cp.vectorFor(collection2, session); // "clone" it so we can clear out the slots

    for (Object iter1 = cp.iteratorFor(collection1); cp.hasNext(iter1); ) {
      Object element1 = cp.next(iter1, session);

      boolean found = false;
      for (int i = 0; i < vector2.size(); i++) {
        if (this.compareElements(element1, vector2.elementAt(i), session)) {
          found = true;
          vector2.setElementAt(XXX, i); // clear out the matching element
          break; // matching element found - skip the rest of them
        }
      }
      if (!found) {
        return false;
      }
    }

    // look for elements that were not in collection1
    for (Enumeration stream = vector2.elements(); stream.hasMoreElements(); ) {
      if (stream.nextElement() != XXX) {
        return false;
      }
    }
    return true;
  }
  /**
   * Build and return the change record that results from comparing the two collection attributes.
   * The order of the elements is significant.
   */
  private ChangeRecord compareAttributeValuesForChangeWithOrder(
      Object cloneCollection,
      Object backupCollection,
      ObjectChangeSet owner,
      AbstractSession session) {
    ContainerPolicy cp = this.getContainerPolicy();

    Vector cloneVector =
        cp.vectorFor(
            cloneCollection,
            session); // convert it to a Vector so we can preserve the order and use indexes
    Vector backupVector =
        cp.vectorFor(backupCollection, session); // "clone" it so we can clear out the slots

    EISOrderedCollectionChangeRecord changeRecord =
        new EISOrderedCollectionChangeRecord(
            owner, this.getAttributeName(), this.getDatabaseMapping());

    for (int i = 0; i < cloneVector.size(); i++) {
      Object cloneElement = cloneVector.elementAt(i);
      boolean found = false;
      for (int j = 0; j < backupVector.size(); j++) {
        if (this.compareElementsForChange(cloneElement, backupVector.elementAt(j), session)) {
          // the clone element was found in the backup collection
          found = true;
          backupVector.setElementAt(XXX, j); // clear out the matching backup element

          changeRecord.addMovedChangeSet(this.buildChangeSet(cloneElement, owner, session), j, i);
          break; // matching backup element found - skip the rest of them
        }
      }
      if (!found) {
        // the clone element was not found, so it must have been added
        changeRecord.addAddedChangeSet(this.buildChangeSet(cloneElement, owner, session), i);
      }
    }

    for (int i = 0; i < backupVector.size(); i++) {
      Object backupElement = backupVector.elementAt(i);
      if (backupElement != XXX) {
        // the backup element was not in the clone collection, so it must have been removed
        changeRecord.addRemovedChangeSet(this.buildChangeSet(backupElement, owner, session), i);
      }
    }

    if (changeRecord.hasChanges()) {
      return changeRecord;
    } else {
      return null;
    }
  }
  /**
   * Build and return the change record that results from comparing the two collection attributes.
   * Ignore the order of the elements.
   */
  private ChangeRecord compareAttributeValuesForChangeWithoutOrder(
      Object cloneCollection,
      Object backupCollection,
      ObjectChangeSet owner,
      AbstractSession session) {
    ContainerPolicy cp = this.getContainerPolicy();

    Vector backupVector =
        cp.vectorFor(backupCollection, session); // "clone" it so we can clear out the slots

    EISCollectionChangeRecord changeRecord =
        new EISCollectionChangeRecord(owner, this.getAttributeName(), this.getDatabaseMapping());
    for (Object cloneIter = cp.iteratorFor(cloneCollection); cp.hasNext(cloneIter); ) {
      Object cloneElement = cp.next(cloneIter, session);

      boolean found = false;
      for (int i = 0; i < backupVector.size(); i++) {
        if (this.compareElementsForChange(cloneElement, backupVector.elementAt(i), session)) {
          // the clone element was found in the backup collection
          found = true;
          backupVector.setElementAt(XXX, i); // clear out the matching backup element
          if (this.mapKeyHasChanged(cloneElement, session)) {
            changeRecord.addChangedMapKeyChangeSet(
                this.buildChangeSet(cloneElement, owner, session));
          }
          break; // matching backup element found - skip the rest of them
        }
      }
      if (!found) {
        // the clone element was not found, so it must have been added
        changeRecord.addAddedChangeSet(this.buildChangeSet(cloneElement, owner, session));
      }
    }

    for (int i = 0; i < backupVector.size(); i++) {
      Object backupElement = backupVector.elementAt(i);
      if (backupElement != XXX) {
        // the backup element was not in the clone collection, so it must have been removed
        changeRecord.addRemovedChangeSet(this.buildChangeSet(backupElement, owner, session));
      }
    }

    if (changeRecord.hasChanges()) {
      return changeRecord;
    } else {
      return null;
    }
  }