/** Adds the worker thread pool attributes to the subysystem add method */
  void parseWorkerThreadPool(final XMLExtendedStreamReader reader, final ModelNode subsystemAdd)
      throws XMLStreamException {
    final int count = reader.getAttributeCount();
    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 WORKER_READ_THREADS:
          if (subsystemAdd.hasDefined(CommonAttributes.WORKER_READ_THREADS)) {
            throw duplicateAttribute(reader, CommonAttributes.WORKER_READ_THREADS);
          }
          RemotingSubsystemRootResource.WORKER_READ_THREADS.parseAndSetParameter(
              value, subsystemAdd, reader);
          break;
        case WORKER_TASK_CORE_THREADS:
          if (subsystemAdd.hasDefined(CommonAttributes.WORKER_TASK_CORE_THREADS)) {
            throw duplicateAttribute(reader, CommonAttributes.WORKER_TASK_CORE_THREADS);
          }
          RemotingSubsystemRootResource.WORKER_TASK_CORE_THREADS.parseAndSetParameter(
              value, subsystemAdd, reader);
          break;
        case WORKER_TASK_KEEPALIVE:
          if (subsystemAdd.hasDefined(CommonAttributes.WORKER_TASK_KEEPALIVE)) {
            throw duplicateAttribute(reader, CommonAttributes.WORKER_TASK_KEEPALIVE);
          }
          RemotingSubsystemRootResource.WORKER_TASK_KEEPALIVE.parseAndSetParameter(
              value, subsystemAdd, reader);
          break;
        case WORKER_TASK_LIMIT:
          if (subsystemAdd.hasDefined(CommonAttributes.WORKER_TASK_LIMIT)) {
            throw duplicateAttribute(reader, CommonAttributes.WORKER_TASK_LIMIT);
          }
          RemotingSubsystemRootResource.WORKER_TASK_LIMIT.parseAndSetParameter(
              value, subsystemAdd, reader);
          break;
        case WORKER_TASK_MAX_THREADS:
          if (subsystemAdd.hasDefined(CommonAttributes.WORKER_TASK_MAX_THREADS)) {
            throw duplicateAttribute(reader, CommonAttributes.WORKER_TASK_MAX_THREADS);
          }
          RemotingSubsystemRootResource.WORKER_TASK_MAX_THREADS.parseAndSetParameter(
              value, subsystemAdd, reader);
          break;
        case WORKER_WRITE_THREADS:
          if (subsystemAdd.hasDefined(CommonAttributes.WORKER_WRITE_THREADS)) {
            throw duplicateAttribute(reader, CommonAttributes.WORKER_WRITE_THREADS);
          }
          RemotingSubsystemRootResource.WORKER_WRITE_THREADS.parseAndSetParameter(
              value, subsystemAdd, reader);
          break;
        default:
          throw unexpectedAttribute(reader, i);
      }
    }

    requireNoContent(reader);
  }
 /**
  * creates option map for remoting connections
  *
  * @param resolver
  * @param model
  * @param defaults
  * @return
  * @throws OperationFailedException
  * @deprecated configuring xnio worker options is no longer supported and should be replaced for
  *     referencing IO subsystem
  */
 @Deprecated
 public static OptionMap create(
     final ExpressionResolver resolver, final ModelNode model, final OptionMap defaults)
     throws OperationFailedException {
   final OptionMap map =
       OptionMap.builder()
           .addAll(defaults)
           .set(
               Options.WORKER_READ_THREADS,
               RemotingSubsystemRootResource.WORKER_READ_THREADS
                   .resolveModelAttribute(resolver, model)
                   .asInt())
           .set(
               Options.WORKER_TASK_CORE_THREADS,
               RemotingSubsystemRootResource.WORKER_TASK_CORE_THREADS
                   .resolveModelAttribute(resolver, model)
                   .asInt())
           .set(
               Options.WORKER_TASK_KEEPALIVE,
               RemotingSubsystemRootResource.WORKER_TASK_KEEPALIVE
                   .resolveModelAttribute(resolver, model)
                   .asInt())
           .set(
               Options.WORKER_TASK_LIMIT,
               RemotingSubsystemRootResource.WORKER_TASK_LIMIT
                   .resolveModelAttribute(resolver, model)
                   .asInt())
           .set(
               Options.WORKER_TASK_MAX_THREADS,
               RemotingSubsystemRootResource.WORKER_TASK_MAX_THREADS
                   .resolveModelAttribute(resolver, model)
                   .asInt())
           .set(
               Options.WORKER_WRITE_THREADS,
               RemotingSubsystemRootResource.WORKER_WRITE_THREADS
                   .resolveModelAttribute(resolver, model)
                   .asInt())
           .set(
               Options.WORKER_READ_THREADS,
               RemotingSubsystemRootResource.WORKER_READ_THREADS
                   .resolveModelAttribute(resolver, model)
                   .asInt())
           .getMap();
   return map;
 }
  private void writeWorkerThreadPoolIfAttributesSet(
      final XMLExtendedStreamWriter writer, final ModelNode node) throws XMLStreamException {
    if (node.hasDefined(CommonAttributes.WORKER_READ_THREADS)
        || node.hasDefined(CommonAttributes.WORKER_TASK_CORE_THREADS)
        || node.hasDefined(CommonAttributes.WORKER_TASK_KEEPALIVE)
        || node.hasDefined(CommonAttributes.WORKER_TASK_LIMIT)
        || node.hasDefined(CommonAttributes.WORKER_TASK_MAX_THREADS)
        || node.hasDefined(CommonAttributes.WORKER_WRITE_THREADS)) {

      writer.writeStartElement(Element.WORKER_THREAD_POOL.getLocalName());

      RemotingSubsystemRootResource.WORKER_READ_THREADS.marshallAsAttribute(node, false, writer);
      RemotingSubsystemRootResource.WORKER_TASK_CORE_THREADS.marshallAsAttribute(
          node, false, writer);
      RemotingSubsystemRootResource.WORKER_TASK_KEEPALIVE.marshallAsAttribute(node, false, writer);
      RemotingSubsystemRootResource.WORKER_TASK_LIMIT.marshallAsAttribute(node, false, writer);
      RemotingSubsystemRootResource.WORKER_TASK_MAX_THREADS.marshallAsAttribute(
          node, false, writer);
      RemotingSubsystemRootResource.WORKER_WRITE_THREADS.marshallAsAttribute(node, false, writer);

      writer.writeEndElement();
    }
  }