docs: private EvaluationResult evaluate(ConfigElement config, RegistryEntry registryEntry, Map<String, ExtendedAttributeDefinition> attributeMap,
                                        List<AttributeDefinition> requiredAttributes, String flatPrefix, boolean ignoreWarnings) throws ConfigEvaluatorException {
          Dictionary<String, Object> map = new ConfigurationDictionary();
          EvaluationContext context = new EvaluationContext(registryEntry, variableEvaluator);
          context.setConfigElement(config);
          context.setProperties(map);
  
          // process attributes based on metatype info
          if (attributeMap != null) {
              context.setAttributeDefinitionMap(attributeMap);
              for (Map.Entry<String, ExtendedAttributeDefinition> entry : attributeMap.entrySet()) {
                  ExtendedAttributeDefinition attributeDef = entry.getValue();
                  if (!attributeDef.isFinal()) {
                      String attributeName = entry.getKey();
                      if (XMLConfigConstants.CFG_PARENT_PID.equals(attributeName))
                          continue;
                      Object value = evaluateMetaTypeAttribute(attributeName, context, attributeDef, flatPrefix, ignoreWarnings);
                      if (value == null &&
                          required(attributeDef.getID(), requiredAttributes) &&
                          //                    requiredAttributes.contains(attributeDef.getDelegate()) &&
                          !context.hasUnresolvedAttribute(attributeDef) &&
                          !ignoreWarnings) {
                          String nodeName = registryEntry.getAlias();
                          if (nodeName == null) {
                              nodeName = registryEntry.getChildAlias();
                          }
                          if (nodeName == null) {
                              nodeName = config.getNodeName();
                          }
  
                          if (config.getId() == null) {
                              Tr.error(tc, "error.missing.required.attribute.singleton", nodeName, attributeName);
                          } else {
                              Tr.error(tc, "error.missing.required.attribute", nodeName, attributeName, config.getId());
                          }
                          context.setValid(false);
                      }
                  }
              }
              for (Map.Entry<String, ExtendedAttributeDefinition> entry : attributeMap.entrySet()) {
                  Object rawValue;
                  ExtendedAttributeDefinition attributeDef = entry.getValue();
                  if (attributeDef.isFinal()) {
                      String attributeName = entry.getKey();
                      if (XMLConfigConstants.CFG_INSTANCE_ID.equals(attributeName)) {
                          rawValue = config.getAttribute(XMLConfigConstants.CFG_INSTANCE_ID);
                          if (!attributeDef.getDefaultValue()[0].equals(rawValue)) {
                              // User has overridden a ibm:final value in server.xml
                              if (rawValue != null) {
                                  Tr.warning(tc, "warning.supplied.config.not.valid", attributeName, rawValue);
                                  context.setValid(false);
                              }
                          }
                      }
                      if (XMLConfigConstants.CFG_PARENT_PID.equals(attributeName))
                          continue;
                      evaluateMetaTypeAttribute(attributeName, context, attributeDef, flatPrefix, ignoreWarnings);
                  }
              }
          }
  
          // process any remaining attributes specified in config
          for (Map.Entry<String, Object> entry : config.getAttributes().entrySet()) {
              String attributeName = entry.getKey();
              if (attributeName.startsWith(XMLConfigConstants.CFG_CONFIG_PREFIX)
                  || context.isProcessed(attributeName)) {
                  continue;
              }
              if (flatPrefix != null
                  && attributeName.equals(XMLConfigConstants.CFG_INSTANCE_ID)
                  // This instanceof should always be true since this is a
                  // flattened element.
                  && config instanceof SimpleElement
                  && !((SimpleElement) config).isUsingNonDefaultId()) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "skipping default id for flattened element");
                  }
                  continue;
              }
              Object attributeValue = entry.getValue();
              evaluateSimpleAttribute(attributeName, attributeValue, context, flatPrefix, ignoreWarnings);
  
          }
  
          if (config.getId() != null) {
              map.put(XMLConfigConstants.CFG_CONFIG_INSTANCE_ID, config.getConfigID().toString());
          }
  
          map.put(XMLConfigConstants.CFG_CONFIG_INSTANCE_DISPLAY_ID, config.getDisplayId());
  
          if (config.getParent() != null && (flatPrefix == null || flatPrefix.equals(""))) {
              if (config.getParent().getId() == null) {
                  map.put(XMLConfigConstants.CFG_PARENT_PID, config.getParent().getConfigID().toString());
              } else {
                  String parentPid = lookupPid(config.getParent().getConfigID());
                  if (parentPid != null)
                      map.put(XMLConfigConstants.CFG_PARENT_PID, parentPid);
              }
          }
  
          //  Evaluate all CopyOf Attributes
          context.evaluateCopiedAttributes();
  
          // Return the EvaluationResult
          return context.getEvaluationResult();
      }