private boolean validateDuplicates() {
   boolean returnGood = true;
   for (CaseInsensitiveString second : duplicates.getKeySet()) {
     List<T> list = duplicates.getListFor(second);
     T good = active.get(second.toString());
     /*
      * CONSIDER Should get CDOMObject reference out of here :(
      */
     if (good instanceof CDOMObject) {
       CDOMObject cdo = (CDOMObject) good;
       for (int i = 0; i < list.size(); i++) {
         T dupe = list.get(i);
         if (cdo.isCDOMEqual((CDOMObject) dupe)) {
           for (Iterator<WeakReference<T>> it = manufactured.iterator(); it.hasNext(); ) {
             WeakReference<T> wr = it.next();
             T mfg = wr.get();
             if (mfg == null) {
               it.remove();
             }
             // Yes this is instance equality, not .equals
             else if (mfg == good) {
               forgetObject(good);
               break;
             }
           }
         }
       }
     }
     if (duplicates.containsListFor(second)) {
       Logging.errorPrint(
           "More than one "
               + factory.getReferenceDescription()
               + " with key/name "
               + good.getKeyName()
               + " was built");
       List<T> dupes = duplicates.getListFor(second);
       StringBuilder sb = new StringBuilder(1000);
       sb.append("Sources: ");
       sb.append(good.isInternal() ? "<internal>" : good.getSourceURI());
       for (T dupe : dupes) {
         sb.append(", ").append(dupe.isInternal() ? "<internal>" : dupe.getSourceURI());
         if (!dupe.getKeyName().equals(good.getKeyName())) {
           Logging.errorPrint("Key case differed for " + dupe.getKeyName());
         }
       }
       Logging.errorPrint(sb.toString());
       returnGood = false;
     }
   }
   return returnGood;
 }
 /**
  * Remove the given object from this AbstractReferenceManufacturer. Returns true if the object was
  * removed from this AbstractReferenceManufacturer; false otherwise.
  *
  * @param item The object to be removed from this AbstractReferenceManufacturer.
  * @return true if the object was removed from this AbstractReferenceManufacturer; false
  *     otherwise.
  */
 @Override
 public boolean forgetObject(T item) {
   if (!factory.isMember(item)) {
     throw new IllegalArgumentException(
         "Object to be forgotten does not match Class " + "of this AbstractReferenceManufacturer");
   }
   String key = active.getKeyFor(item);
   if (key == null) {
     /*
      * TODO This is a bug - the key name is not necessarily loaded into
      * the object, it may have been consumed by the object context... :P
      */
     CaseInsensitiveString ocik = new CaseInsensitiveString(item.getKeyName());
     duplicates.removeFromListFor(ocik, item);
   } else {
     CaseInsensitiveString ocik = new CaseInsensitiveString(key);
     List<T> list = duplicates.getListFor(ocik);
     if (list == null) {
       // No replacement
       active.remove(key);
     } else {
       T newActive = duplicates.getElementInList(ocik, 0);
       duplicates.removeFromListFor(ocik, newActive);
       active.put(key, newActive);
     }
   }
   return true;
 }
 /**
  * Gets the object represented by the given identifier. Will return null if an object with the
  * given identifier is not present in this AbstractReferenceManufacturer.
  *
  * <p>Note that this is testing *object* presence. This will not return an object if a reference
  * for the given identifier has been requested; it will only return true if an object with the
  * given identifier has actually been constructed by or imported into this
  * AbstractReferenceManufacturer.
  *
  * @param key identifier of the object to be returned
  * @return The object stored in this AbstractReferenceManufacturer with the given identifier, or
  *     null if this AbstractReferenceManufacturer does not contain an object with the given
  *     identifier.
  */
 @Override
 public T getObject(String key) {
   T po = active.get(key);
   if (po != null) {
     List<T> list = duplicates.getListFor(new CaseInsensitiveString(key));
     if ((list != null) && !list.isEmpty()) {
       Logging.errorPrint(
           "Reference to Constructed "
               + factory.getReferenceDescription()
               + " "
               + key
               + " is ambiguous");
       StringBuilder sb = new StringBuilder(1000);
       sb.append("Locations: ");
       sb.append(po.getSourceURI());
       for (T dupe : list) {
         sb.append(", ");
         sb.append(dupe.getSourceURI());
       }
       Logging.errorPrint(sb.toString());
     }
     return po;
   }
   return null;
 }
 /**
  * Injects all objects from the given ReferenceManufacturer into this
  * AbstractReferenceManufacturer. Effectively this is a bulk addObject for all of the objects
  * contained in the given ReferenceManufacturer.
  *
  * <p>Note that this imports only the objects, and NOT references. This
  * AbstractReferenceManufacturer does inherit any deferred objects (triggered through
  * constructIfNecessary) from the given ReferenceManufacturer.
  *
  * @param arm The ReferenceManufacturer from which the objects should be imported into this
  *     AbstractReferenceManufacturer
  */
 @Override
 public void injectConstructed(ReferenceManufacturer<T> arm) {
   // Must maintain order
   for (T value : active.insertOrderValues()) {
     arm.addObject(value, active.getKeyFor(value));
   }
   for (CaseInsensitiveString cis : duplicates.getKeySet()) {
     for (T obj : duplicates.getListFor(cis)) {
       arm.addObject(obj, cis.toString());
     }
   }
   for (String s : deferred) {
     arm.constructIfNecessary(s);
   }
 }