gt:                     throw unexpectedAttribute(reader, i);
context: /*
   * Copyright 2015 Red Hat, Inc.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.jboss.as.ee.subsystem;
  
  import org.jboss.as.controller.PathAddress;
  import org.jboss.as.controller.operations.common.Util;
  import org.jboss.as.ee.logging.EeLogger;
  import org.jboss.dmr.ModelNode;
  import org.jboss.staxmapper.XMLElementReader;
  import org.jboss.staxmapper.XMLExtendedStreamReader;
  
  import javax.xml.stream.XMLStreamConstants;
  import javax.xml.stream.XMLStreamException;
  import java.util.Collections;
  import java.util.EnumSet;
  import java.util.List;
  
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.NAME;
  import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP_ADDR;
  import static org.jboss.as.controller.parsing.ParseUtils.missingRequired;
  import static org.jboss.as.controller.parsing.ParseUtils.requireNoAttributes;
  import static org.jboss.as.controller.parsing.ParseUtils.requireNoContent;
  import static org.jboss.as.controller.parsing.ParseUtils.requireNoNamespaceAttribute;
  import static org.jboss.as.controller.parsing.ParseUtils.unexpectedAttribute;
  import static org.jboss.as.controller.parsing.ParseUtils.unexpectedElement;
  
  /**
   */
  class EESubsystemParser50 implements XMLStreamConstants, XMLElementReader<List<ModelNode>> {
  
      EESubsystemParser50() {
  
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      public void readElement(XMLExtendedStreamReader reader, List<ModelNode> list) throws XMLStreamException {
          // EE subsystem doesn't have any attributes, so make sure that the xml doesn't have any
          requireNoAttributes(reader);
          final PathAddress subsystemPathAddress = PathAddress.pathAddress(EeExtension.PATH_SUBSYSTEM);
          final ModelNode eeSubSystem = Util.createAddOperation(subsystemPathAddress);
          // add the subsystem to the ModelNode(s)
          list.add(eeSubSystem);
  
          // elements
          final EnumSet<Element> encountered = EnumSet.noneOf(Element.class);
          while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
              switch (Namespace.forUri(reader.getNamespaceURI())) {
                  case EE_5_0: {
                      final Element element = Element.forName(reader.getLocalName());
                      if (!encountered.add(element)) {
                          throw unexpectedElement(reader);
                      }
                      switch (element) {
                          case GLOBAL_MODULES: {
                              final ModelNode model = parseGlobalModules(reader);
                              eeSubSystem.get(GlobalModulesDefinition.GLOBAL_MODULES).set(model);
                              break;
                          }
                          case GLOBAL_DIRECTORIES: {
                              parseGlobalDirectories(reader, list, subsystemPathAddress);
                              break;
                          }
                          case EAR_SUBDEPLOYMENTS_ISOLATED: {
                              final String earSubDeploymentsIsolated = parseEarSubDeploymentsIsolatedElement(reader);
                              // set the ear subdeployment isolation on the subsystem operation
                              EeSubsystemRootResource.EAR_SUBDEPLOYMENTS_ISOLATED.parseAndSetParameter(earSubDeploymentsIsolated, eeSubSystem, reader);
                              break;
                          }
                          case SPEC_DESCRIPTOR_PROPERTY_REPLACEMENT: {
                              final String enabled = parseSpecDescriptorPropertyReplacement(reader);
                              EeSubsystemRootResource.SPEC_DESCRIPTOR_PROPERTY_REPLACEMENT.parseAndSetParameter(enabled, eeSubSystem, reader);
                              break;
                          }
                          case JBOSS_DESCRIPTOR_PROPERTY_REPLACEMENT: {
                              final String enabled = parseJBossDescriptorPropertyReplacement(reader);
                              EeSubsystemRootResource.JBOSS_DESCRIPTOR_PROPERTY_REPLACEMENT.parseAndSetParameter(enabled, eeSubSystem, reader);
                              break;
                          }
                          case ANNOTATION_PROPERTY_REPLACEMENT: {
                              final String enabled = parseEJBAnnotationPropertyReplacement(reader);
                              EeSubsystemRootResource.ANNOTATION_PROPERTY_REPLACEMENT.parseAndSetParameter(enabled, eeSubSystem, reader);
                              break;
                          }
                          case CONCURRENT: {
                              parseConcurrent(reader, list, subsystemPathAddress);
                              break;
                          }
                          case DEFAULT_BINDINGS: {
                              parseDefaultBindings(reader, list, subsystemPathAddress);
                              break;
                          }
                          default: {
                              throw unexpectedElement(reader);
                          }
                      }
                      break;
                  }
                  default: {
                      throw unexpectedElement(reader);
                  }
              }
          }
      }
  
      static ModelNode parseGlobalModules(XMLExtendedStreamReader reader) throws XMLStreamException {
  
          ModelNode globalModules = new ModelNode();
  
          requireNoAttributes(reader);
  
          while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
              switch (Element.forName(reader.getLocalName())) {
                  case MODULE: {
                      final ModelNode module = new ModelNode();
                      final int count = reader.getAttributeCount();
                      String name = null;
                      String slot = null;
                      String annotations = null;
                      String metaInf = null;
                      String services = null;
                      for (int i = 0; i < count; i++) {
                          requireNoNamespaceAttribute(reader, i);
                          final String value = reader.getAttributeValue(i);
                          final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
                          switch (attribute) {
                              case NAME:
                                  if (name != null) {
                                      throw unexpectedAttribute(reader, i);
                                  }
                                  name = value;
                                  GlobalModulesDefinition.NAME_AD.parseAndSetParameter(name, module, reader);
                                  break;
                              case SLOT:
                                  if (slot != null) {
                                      throw unexpectedAttribute(reader, i);
                                  }
                                  slot = value;
                                  GlobalModulesDefinition.SLOT_AD.parseAndSetParameter(slot, module, reader);
                                  break;
                              case ANNOTATIONS:
                                  if (annotations != null) {
                                      throw unexpectedAttribute(reader, i);
                                  }
                                  annotations = value;
                                  GlobalModulesDefinition.ANNOTATIONS_AD.parseAndSetParameter(annotations, module, reader);
                                  break;
  
                              case SERVICES:
                                  if (services != null) {
                                      throw unexpectedAttribute(reader, i);
                                  }
                                  services = value;
                                  GlobalModulesDefinition.SERVICES_AD.parseAndSetParameter(services, module, reader);
                                  break;
  
                              case META_INF:
                                  if (metaInf != null) {
                                      throw unexpectedAttribute(reader, i);
                                  }
                                  metaInf = value;
                                  GlobalModulesDefinition.META_INF_AD.parseAndSetParameter(metaInf, module, reader);
                                  break;
                              default:
                                  throw unexpectedAttribute(reader, i);
                          }
                      }
                      if (name == null) {
                          throw missingRequired(reader, Collections.singleton(NAME));
                      }
  
                      globalModules.add(module);
  
                      requireNoContent(reader);
                      break;
                  }
                  default: {
                      throw unexpectedElement(reader);
                  }
              }
          }
          return globalModules;
      }
  
      static String parseEarSubDeploymentsIsolatedElement(XMLExtendedStreamReader reader) throws XMLStreamException {
  
          // we don't expect any attributes for this element.
          requireNoAttributes(reader);
  
          final String value = reader.getElementText();
          if (value == null || value.trim().isEmpty()) {
              throw EeLogger.ROOT_LOGGER.invalidValue(value, Element.EAR_SUBDEPLOYMENTS_ISOLATED.getLocalName(), reader.getLocation());
          }
          return value.trim();
      }
  
  
      static String parseSpecDescriptorPropertyReplacement(XMLExtendedStreamReader reader) throws XMLStreamException {
  
          // we don't expect any attributes for this element.
          requireNoAttributes(reader);
  
          final String value = reader.getElementText();
          if (value == null || value.trim().isEmpty()) {
              throw EeLogger.ROOT_LOGGER.invalidValue(value, Element.SPEC_DESCRIPTOR_PROPERTY_REPLACEMENT.getLocalName(), reader.getLocation());
          }
          return value.trim();
      }
  
  
      static String parseJBossDescriptorPropertyReplacement(XMLExtendedStreamReader reader) throws XMLStreamException {
  
          // we don't expect any attributes for this element.
          requireNoAttributes(reader);
  
          final String value = reader.getElementText();
          if (value == null || value.trim().isEmpty()) {
              throw EeLogger.ROOT_LOGGER.invalidValue(value, Element.JBOSS_DESCRIPTOR_PROPERTY_REPLACEMENT.getLocalName(), reader.getLocation());
          }
          return value.trim();
      }
  
      static String parseEJBAnnotationPropertyReplacement(XMLExtendedStreamReader reader) throws XMLStreamException {
          // we don't expect any attributes for this element.
          requireNoAttributes(reader);
  
          final String value = reader.getElementText();
          return value.trim();
      }
  
      static void parseConcurrent(XMLExtendedStreamReader reader, List<ModelNode> operations, PathAddress subsystemPathAddress) throws XMLStreamException {
          requireNoAttributes(reader);
          while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
              final Element element = Element.forName(reader.getLocalName());
              switch (element) {
                  case CONTEXT_SERVICES: {
                      parseContextServices(reader, operations, subsystemPathAddress);
                      break;
                  }
                  case MANAGED_THREAD_FACTORIES: {
                      parseManagedThreadFactories(reader, operations, subsystemPathAddress);
                      break;
                  }
                  case MANAGED_EXECUTOR_SERVICES: {
                      parseManagedExecutorServices(reader, operations, subsystemPathAddress);
                      break;
                  }
                  case MANAGED_SCHEDULED_EXECUTOR_SERVICES: {
                      parseManagedScheduledExecutorServices(reader, operations, subsystemPathAddress);
                      break;
                  }
                  default: {
                      throw unexpectedElement(reader);
                  }
              }
          }
      }
  
      static void parseContextServices(XMLExtendedStreamReader reader, List<ModelNode> operations, PathAddress subsystemPathAddress) throws XMLStreamException {
          requireNoAttributes(reader);
          boolean empty = true;
          while (reader.hasNext() && reader.nextTag() != END_ELEMENT) {
              switch (Element.forName(reader.getLocalName())) {
                  case CONTEXT_SERVICE: {
                      empty = false;
                      parseContextService(reader, operations, subsystemPathAddress);
                      break;
                  }
                  default: {
                      throw unexpectedElement(reader);
                  }
              }
          }
          if (empty) {
              throw missingRequired(reader, EnumSet.of(Element.CONTEXT_SERVICE));
          }
      }
  
      static void parseContextService(XMLExtendedStreamReader reader, List<ModelNode> operations, PathAddress subsystemPathAddress) throws XMLStreamException {
          final ModelNode addOperation = Util.createAddOperation();
          final int count = reader.getAttributeCount();
          String name = null;
          final EnumSet<Attribute> required = EnumSet.of(Attribute.NAME, Attribute.JNDI_NAME);
          for (int i = 0; i < count; i++) {
              requireNoNamespaceAttribute(reader, i);
              final String value = reader.getAttributeValue(i);
              final Attribute attribute = Attribute.forName(reader.getAttributeLocalName(i));
              required.remove(attribute);
              switch (attribute) {
                  case NAME:
                      name = value.trim();
                      break;
                  case JNDI_NAME:
                      ContextServiceResourceDefinition.JNDI_NAME_AD.parseAndSetParameter(value, addOperation, reader);
                      break;
                  case USE_TRANSACTION_SETUP_PROVIDER:
                      ContextServiceResourceDefinition.USE_TRANSACTION_SETUP_PROVIDER_AD.parseAndSetParameter(value, addOperation, reader);
                      break;
                  default:
  