docs: private void processXMLEnvEntries(List<? extends EnvEntry> envEntries)
                      throws InjectionException
      {
          for (EnvEntry envEntry : envEntries)
          {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  Tr.debug(tc, "processing : " + envEntry);
  
              // If XML has previously been read and an injection binding with the same
              // jndi name has been created, get the current injection binding and merge
              // the new env entry into it.
              String jndiName = envEntry.getName();
              InjectionBinding<Resource> injectionBinding = ivAllAnnotationsCollection.get(jndiName);
              if (injectionBinding != null)
              {
                  ((ResourceInjectionBinding) injectionBinding).merge(envEntry);
              }
              else
              {
                  String mappedName = envEntry.getMappedName();
                  String description = getDescription(envEntry);
                  String lookup = envEntry.getLookupName(); // F743-21028.4
                  if (lookup != null) {
                      lookup = lookup.trim();
                  }
  
                  // Previously, the env-entry-value was converted to the
                  // env-entry-type at this time, however, the env-entry-type
                  // is an optional parameter, and so may need to be obtained from
                  // any corresponding annotation(s).  The conversion of the value
                  // to the correct type is now done during 'resolve', after all
                  // metadata has been collected.                         F743-22218.3
  
                  List<InjectionTarget> targets = envEntry.getInjectionTargets();
  
                  // Note: env-entry-type will be determined in binding constructor,
                  //       and updated in annotation at that time.          F743-25853
  
                  ResourceImpl resourceAnnotation = new ResourceImpl(jndiName,
                                  null,
                                  mappedName,
                                  description,
                                  lookup); // F743-21028.4
                  injectionBinding = new ResourceInjectionBinding(resourceAnnotation,
                                  envEntry,
                                  ivNameSpaceConfig); // d479669
                  addInjectionBinding(injectionBinding);
  
                  // d654054
                  // As part of adding an InjectionTarget, validation is done to ensure
                  // that the specified injection type is compatible with the type of
                  // variable being injected into.
                  //
                  // If the user omits the <type> setting from their XML, then the
                  // EnvEntry given to us by WCCM has a null value for the type, and
                  // that will cause us to NPE during the compatibility check.  To
                  // avoid this, we ensure that we always have a non-null injection
                  // type passed into that check, and if the user omitted the <type>
                  // from the XML, then we default to java.lang.Object
                  //
                  // The other XML types (MessageDestRef, ResourceRef, ResourceEnvRef)
                  // use the .loadTypeClass() method to ensure that we've got a valid
                  // injection type.  However, we can't use that method directly, because
                  // unlike the other XML types, the EnvEntry does not have a method
                  // that returns the injection type as a String (which is the required
                  // input to the .loadTypeClass() method).  Rather, the EnvEntry type
                  // is represented by an int, which is converted into the corresponding
                  // Class by the .getEnvEntryType() method...and after we're done calling
                  // that, we've already got the Class, so there is no point in calling
                  // the .loadTypeClass()
  
                  // Support multiple injection targets
                  if (!targets.isEmpty())
                  {
                      Class<?> injectionType = injectionBinding.getInjectionClassType();
  
                      for (InjectionTarget target : targets)
                      {
                          String targetClassName = target.getInjectionTargetClassName();
                          String targetName = target.getInjectionTargetName();
                          injectionBinding.addInjectionTarget(injectionType, targetName, targetClassName);
                      }
                  } // if targets
              } // else binding with same name not found
          } // for ivEnvEntries
      }